_modules/.pnpm/vitest@2.1.9_@types+node@24.7.0_jsdom@27.0.0_bufferutil@4.0.9_postcss@8.5.6_utf-8-valid_7a9f9ab30ae2494ce58bc7fcf1b9ad61/node_modules/vitest/dist/chunks/runBaseTests.3qpJUEJM.js:112:3)\n    at runBaseTests (file:///home/runner/work/RSSHub/RSSHub/node_modules/.pnpm/vitest@2.1.9_@types+node@24.7.0_jsdom@27.0.0_bufferutil@4.0.9_postcss@8.5.6_utf-8-valid_7a9f9ab30ae2494ce58bc7fcf1b9ad61/node_modules/vitest/dist/chunks/base.BZZh4cSm.js:29:3)\n    at ForksBaseWorker.executeTests (file:///home/runner/work/RSSHub/RSSHub/node_modules/.pnpm/vitest@2.1.9_@types+node@24.7.0_jsdom@27.0.0_bufferutil@4.0.9_postcss@8.5.6_utf-8-valid_7a9f9ab30ae2494ce58bc7fcf1b9ad61/node_modules/vitest/dist/workers/forks.js:27:7)\n    at execute (file:///home/runner/work/RSSHub/RSSHub/node_modules/.pnpm/vitest@2.1.9_@types+node@24.7.0_jsdom@27.0.0_bufferutil@4.0.9_postcss@8.5.6_utf-8-valid_7a9f9ab30ae2494ce58bc7fcf1b9ad61/node_modules/vitest/dist/worker.js:127:5)\n    at onMessage (file:///home/runner/work/RSSHub/RSSHub/node_modules/.pnpm/tinypool@1.1.1/node_modules/tinypool/dist/entry/process.js:39:18)"}' />

|  分类名  | `type` 值 |  子类名  | `sub` 值 |
| :------: | :-------- | :------: | :------- |
|   首页   | `index`   |          |          |
| 学院新闻 | `xyxw`    |   全部   | `all`    |
|          |           | 学院要闻 | `xyyw`   |
|          |           | 合作交流 | `hzjl`   |
|          |           | 媒体聚焦 | `mtjj`   |
|          |           | 学工要闻 | `xgyw`   |
| 科学研究 | `kxyj`    |   全部   | `all`    |
|          |           | 学术报告 | `xsbg`   |
|          |           | 学术交流 | `xsjl`   |
|          |           | 学术成果 | `kycg`   |
|          |           | 申报信息 | `sbxx`   |
| 通知公告 | `tzgg`    |   全部   | `all`    |
|          |           | 学院通知 | `xytz`   |
|          |           | 教学动态 | `jxdt`   |
|          |           | 学术动态 | `xsdt`   |
|          |           | 人才引进 | `rcyj`   |

### Unknown <Site url="cs.whu.edu.cn" size="sm" />

<Route namespace="whu" :data='{"path":"/hyxt/:category{.+}?","name":"Unknown","maintainers":[],"location":"hyxt.ts","heat":0,"topFeeds":[]}' :test='undefined' />

### 水利水电学院公告 <Site url="cs.whu.edu.cn" size="sm" />

<Route namespace="whu" :data='{"path":"/swr


en multiple calls are made to dlopen(). We've
       covered the former case - now we can handle the latter by calling
       dlopen() again here. */
    return dlopen(pcFilename, iFlag);
}

/*****************************************************************************/

void *
loadLADSPAPluginLibrary(const char * pcPluginFilename) {

    void * pvPluginHandle;

    pvPluginHandle = dlopenLADSPA(pcPluginFilename, RTLD_NOW);
    if (!pvPluginHandle) {
        fprintf(stderr,
                "Failed to load plugin \"%s\": %s\n",
                pcPluginFilename,
                dlerror());
#if 0
        exit(1);
#else
        return NULL;
#endif
    }

    return pvPluginHandle;
}

/*****************************************************************************/

void
unloadLADSPAPluginLibrary(void * pvLADSPAPluginLibrary) {
    dlclose(pvLADSPAPluginLibrary);
}

/*****************************************************************************/

const LADSPA_Descriptor *
findLADSPAPluginDescriptor(void * pvLADSPAPluginLibrary,
        const char * pcPluginLibraryFilename,
        const char * pcPluginLabel) {

    const LADSPA_Descriptor * psDescriptor;
    LADSPA_Descriptor_Function pfDescriptorFunction;
    unsigned long lPluginIndex;

    dlerror();
    pfDescriptorFunction
        = (LADSPA_Descriptor_Function)dlsym(pvLADSPAPluginLibrary,
                "ladspa_descriptor");
    if (!pfDescriptorFunction) {
        const char * pcError = dlerror();
        if (pcError)
            fprintf(stderr,
                    "Unable to find ladspa_descriptor() function in plugin "
                    "library file \"%s\": %s.\n"
                    "Are you sure this is a LADSPA plugin file?\n",
                    pcPluginLibraryFilename,
                    pcError);
#if 0
        exit(1);
#else
        return NULL;
#endif
    }

    for (lPluginIndex = 0;; lPluginIndex++) {
        psDescriptor = pfDescriptorFunction(lPluginIndex);
        if (psDescriptor == NULL) {
            fprintf(stderr,
                    "Unable to find label \"%s\" in plugin library file \"%s\".\n",
                    pcPluginLabel,
                    pcPluginLibraryFilename);
#if 0
            exit(1);
#else
            return NULL;
#endif
        }
        if (strcmp(psDescriptor->Label, pcPluginLabel) == 0)
            return psDescriptor;
    }
}

/*****************************************************************************/

/* EOF */


min != float("-inf"):
            self.q_min.setValue(self.bus.q_min)
        else:
            self.q_min.clearValue()
        if self.bus.q_max != float("inf"):
            self.q_max.setValue(self.bus.q_max)
        else:
            self.q_max.clearValue()
        if self.bus.g_shunt != 0:
            self.shunt_g.setValue(self.bus.g_shunt)
        else:
            self.shunt_g.clearValue()
        if self.bus.b_shunt != 0:
            self.shunt_b.setValue(self.bus.b_shunt)
        else:
            self.shunt_b.clearValue()

    def circuit_listener(self, element: NetworkElement, event: ElementEvent):
        if event is ElementEvent.UPDATED and isinstance(element, Bus) and element.id == self.bus.id:
            self.bus = element
            self.update_values()
            return


.crate] ?? null : null
    })
  }

  return output
}

export async function runCargoSortCheck(args: string[] = []): Promise<CargoSortCheckError[]> {
  // eslint-disable-next-line @typescript-eslint/no-unused-vars
  const { exitInfo, stdout, stderr } = await runCargoSortCommand('--check', args)

  const errors = []

  for (const line of splitLines(stderr)) {
    const error = parseError(line)
    if (error == null) {
      continue
    }

    errors.push({
      error,
      crate: parseForCrate(line)
    })
  }

  return errors
}

export async function runCargoSortPrint(args: string[] = []): Promise<CargoSortPrintCrates> {
  // eslint-disable-next-line @typescript-eslint/no-unused-vars
  const { exitInfo, stdout, stderr } = await runCargoSortCommand('--print', args)
  return parseOutput(stdout)
}

export async function runCargoSortCommand(command: string, args: string[] = []): Promise<CommandOutput> {
  return runCommand('cargo', ['sort', command, '--grouped', '--workspace', '--order', ORDER, ...args].filter(Boolean), {
    env: {
      ...process.env,
      NO_COLOR: 'true'
    }
  })
}

function parseOutput(output: string): CargoSortPrintCrates {
  const crates: CargoSortPrintCrates = {}
  let last = null

  for (const line of splitLines(output)) {
    const crate = parseChecking(line)
    if (crate !== null) {
      if (last !== null) {
        crates[last.crate] = last.toml
      }

      last = {
        crate,
        toml: ''
      }
    } else if (last !== null) {
      // `last` will always be non-null in this case, the check is to make eslint happy

      if (last.toml.length > 0) {
        last.toml += '\n'
      }

      last.toml += line
    }
  }

  if (last !== null) {
    crates[last.crate] = last.toml
  }

  return crates
}

function parseChecking(line: string): string | null {
  const match = RE_CHECKING_CRATE.exec(line)
  if (match == null) {
    return null
  }

  // eslint-disable-next-line @typescript-eslint/no-unused-vars
  const [_input, crate_name] = match
  return crate_name
}

function parseError(line: string): string | null {
  const match = RE_ERROR.exec(line)
  if (match == null) {
    return null
  }

  // eslint-disable-next-line @typescript-eslint/no-unused-vars
  const [_input, err] = match
  return err
}

function parseForCrate(line: string): string | null {
  const match = RE_FOR_CRATE.exec(line)
  if (match == null) {
    return null
  }

  // eslint-disable-next-line @typescript-eslint/no-unused-vars
  const [_input, crate_name] = match
  return crate_name
}
/*! Copyright (c) 2020, XAPPmedia */

import { expect } from "chai";
import { requestSlotsToString } from "../requestSlotsToString";

describe(`#${requestSlotsToString.name}()`, () => {
    it('returns the correct value', () => {
        expect(requestSlotsToString(undefined)).to.equal("");
        // @ts-expect-error For testing bad input
        expect(requestSlotsToString(true)).to.equal("");
        expect(requestSlotsToString(null)).to.equal("");
        // @ts-expect-error For testing bad input
        expect(requestSlotsToString([])).to.equal("");
        expect(requestSlotsToString({})).to.equal("");


20.19 14.88 19.65 15.89 18.77C15.64 18.72 15.39 18.65 15.15 18.59C14.38 18.41 13.65 18.22 12.81 18.19L12.62 18.18L12.7 18C13.1 17.2 14.8 14.41 15.23 13.63L15.34 13.81C16 14.77 16.73 15.5 17.58 16.07C17.69 15.64 17.75 15.2 17.75 14.75C17.75 13.25 17.11 11.89 16.09 10.9C15.4 10.24 14.53 9.74 13.55 9.5C13.85 10.5 14.2 11.5 14.59 12.35L14.62 12.4L14.59 12.46C14.2 13.22 13.76 13.95 13.33 14.66C12.94 15.3 12.54 15.96 12.18 16.64L12.08 16.83L11.96 16.65C11.39 15.82 9.75 13.06 9.41 12.5C9.81 11.5 10.15 10.5 10.45 9.5C9.5 9.78 8.7 10.26 8.03 10.9C7 11.88 6.37 13.25 6.37 14.74C6.37 15.16 6.42 15.56 6.5 15.95",
        MaterialIconKind.Knife => "M20.62,2C23.97,7.61 12.47,20.15 12.47,20.15L9.6,17.28L4.91,22L2.77,19.86L20.62,2Z",
        MaterialIconKind.KnifeMilitary => "M22,2L17.39,3.75L10.46,10.68L14,14.22L20.92,7.29C22.43,5.78 22,2 22,2M8.33,10L6.92,11.39L8.33,12.8L2.68,18.46L6.21,22L11.87,16.34L13.28,17.76L14.7,16.34L8.33,10Z",
        MaterialIconKind.Knob => "M12 2C6.5 2 2 6.5 2 12S6.5 22 12 22 22 17.5 22 12 17.5 2 12 2M13 10H11V4.1C11.3 4 11.7 4 12 4S12.7 4 13 4.1V10Z",
        MaterialIconKind.Koala => "M19 3C18.1 3 15.5 3 14.3 6.1C13.9 6 13.4 6 13 6H11C10.6 6 10.1 6 9.7 6.1C8.5 3 5.9 3 5 3C4 3 1 4 1 9C1 12.6 3.5 13.6 5 13.9V15C5 18.3 7.7 21 11 21H13C16.3 21 19 18.3 19 15V13.9C20.5 13.6 23 12.6 23 9C23 4 20 3 19 3M5 12V12.4C2.9 11.8 3.3 9.5 4.3 8.7C4 8.3 3 9 3 8.6C3 8.1 4.8 7.4 5.1 7.3C4.8 6.8 3.6 7 3.6 6.6C3.6 6.3 4.8 5.8 5.8 6C6.3 6.1 6.9 6.3 7.4 6.7C6 8 5 9.8 5 12M8.5 15C6.5 15 6.5 12 8.5 12C10.5 12 10.5 15 8.5 15M12.5 18H11.5C10.8 18 10.3 17.3 10.6 16.7L11.3 13.7C11.4 13.3 11.8


ource_type"] == "base64":
            audio_format = block["mime_type"].split("/")[-1]
            formatted_block = {
                "type": "input_audio",
                "input_audio": {"data": block["data"], "format": audio_format},
            }
        else:
            error_msg = "source_type base64 is required for audio blocks."
            raise ValueError(error_msg)
    else:
        error_msg = f"Block of type {block['type']} is not supported."
        raise ValueError(error_msg)

    return formatted_block


.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

use {std::cell::RefCell, std::rc::Rc, tokio};

// A doubly-linked list of Notify objects. Each node represents a slot in the
// sequence. A task acquires its spot in the sequence by waiting on `ready`,
// then releases its spot by notifying the next task's `ready`. When a node is
// dropped, it removes itself from the list.
//
// This creates a reference-counting cycle. We break the cycle by removing a
// Node from the list when it is dropped (via Ticket or Lock).
//
// Our linked list needs the following features:
//
// - push back
// - an iterator with "next" and "erase" operations
// - the ability to hold multiple such iterators simultaneously
//
// The second feature is not provided by std::collections::LinkedList. It can be
// simulated with `split_at` at the cost of great awkwardness. The experimental
// cursors proposal (https://github.com/rust-lang/rust/issues/58533) supports the
// second feature via CursorMut, but CursorMuts require a mutable borrow on the
// list, which implies that only one async task can hold CursorMuts at any time.
// Hence we roll our own list.
type NodeRef = Rc<RefCell<Node>>;
type ListRef = Rc<RefCell<List>>;

struct Node {
    prev: Option<NodeRef>,
    next: Option<NodeRef>,
    list: ListRef,
    ready: Rc<tokio::sync::Notify>,
}

struct List {
    head: Option<NodeRef>,
    tail: Option<NodeRef>,
}

impl Node {
    fn new_at_tail(list: ListRef) -> Self {
        let old_tail = list.borrow().tail.clone();
        Node { prev: old_tail, next: None, list: list, ready: Rc::new(tokio::sync::Notify::new()) }
    }

    fn erase(&self) {
        // Disconnect from the linked list.
        if let Some(prev) = &self.prev {
            prev.borrow_mut().next = self.next.clone();
        }
        if let Some(next) = &self.next {
            next.borrow_mut().prev = self.prev.clone();
        }
        if let None = self.prev {
            self.list.borrow_mut().head = self.next.clone();
        }
        if let None = self.next {
            self.list.borrow_mut().tail = self.prev.clone();
        }

        // If this node was at the head of the list, the next node is ready.
        match (&self.prev, &self.next) {
            (None, Some(next)) => next.borrow().ready.notify(),
            _ => (),
        };
    }
}

pub struct Sequencer {
    list: ListRef,
}

/// A Sequencer can be used create a sequence of async tasks. To enter a sequence,
/// a task first obtains a `Ticket` which marks a slot in the sequence. Once the
/// task is ready to serialize with the sequence, it should await `Task::wait_turn()`,
/// then hold onto the returned `Lock` until it is ready to release the next ticket
/// in the sequence.
///
/// If a task drops its `Ticket` before awaiting `Task::wait_turn()`, the task's
/// slot is dropped from the sequence.
impl Sequencer {
    pub fn new() -> Sequencer {
        Sequencer { list: Rc::new(RefCell::new(List { head: None, tail: None })) }
    }

    pub fn next(&mut self) -> Ticket {
        let node = Rc::new(RefCell::new(Node::new_at_tail(self.list.clone())));

        // Node goe


                console.log("verified y");
                quadArray[i].addChara(event, quadArray[i]);
                console.log("quadrant " + i);
            }
        }
    }

    win();

};

function win(): void {

    if (quad0.icon === "puppy" && quad1.icon === "puppy" && quad2.icon === "puppy") {
        moo();
    } else if (quad3.icon === "puppy" && quad4.icon === "puppy" && quad5.icon === "puppy") {
        moo();
    } else if (quad6.icon === "puppy" && quad7.icon === "puppy" && quad8.icon === "puppy") {
        moo();
    } else if (quad0.icon === "puppy" && quad3.icon === "puppy" && quad6.icon === "puppy") {
        moo();
    } else if (quad1.icon === "puppy" && quad4.icon === "puppy" && quad7.icon === "puppy") {
        moo();
    } else if (quad2.icon === "puppy" && quad5.icon === "puppy" && quad8.icon === "puppy") {
        moo();
    } else if (quad0.icon === "puppy" && quad4.icon === "puppy" && quad8.icon === "puppy") {
        moo();
    } else if (quad2.icon === "puppy" && quad4.icon === "puppy" && quad6.icon === "puppy") {
        moo();
    } else if (quad0.icon === "kitty" && quad1.icon === "kitty" && quad2.icon === "kitty") {
        moo();
    } else if (quad3.icon === "kitty" && quad4.icon === "kitty" && quad5.icon === "kitty") {
        moo();
    } else if (quad6.icon === "kitty" && quad7.icon === "kitty" && quad8.icon === "kitty") {
        moo();
    } else if (quad0.icon === "kitty" && quad3.icon === "kitty" && quad6.icon === "kitty") {
        moo();
    } else if (quad1.icon === "kitty" && quad4.icon === "kitty" && quad7.icon === "kitty") {
        moo();
    } else if (quad2.icon === "kitty" && quad5.icon === "kitty" && quad8.icon === "kitty") {
        moo();
    } else if (quad0.icon === "kitty" && quad4.icon === "kitty" && quad8.icon === "kitty") {
        moo();
    } else if (quad2.icon === "kitty" && quad4.icon === "kitty" && quad6.icon === "kitty") {
        moo();
    }
}

function moo(): void {
    let cow: Sprite = Sprite.fromImage("./bigcow.png");
    let mooSound: HTMLAudioElement = document.getElementById("moo") as HTMLAudioElement;
    cow.x = 60;
    cow.y = 70;
    app.stage.addChild(cow);
    mooSound.play();

}

import {CHAR_NO_BREAK_SPACE} from '@taiga-ui/cdk';
import {formatNumber} from '../format-number';

describe('Number formatting', () => {
    it('inserts delimiter for numbers > 999', () => {
        expect(formatNumber(1000)).toBe(`1${CHAR_NO_BREAK_SPACE}000`);
    });

    it('correctly inserts the separator for one higher order', () => {
        expect(formatNumber(1234567)).toBe(
            `1${CHAR_NO_BREAK_SPACE}234${CHAR_NO_BREAK_SPACE}567`,
        );
    });

    it('correctly inserts the separator for the two higher orders', () => {
        expect(formatNumber(12345678)).toBe(
            `12${CHAR_NO_BREAK


radio is zone-based, which is different from how '
                   'most radios work (that CHIRP supports). The zone count '
                   'can be adjusted in the Settings tab, but you must save '
                   'and re-load the file after changing that value in order '
                   'to be able to add/edit memories there.')
        rp.experimental = ('This driver is very experimental. Every attempt '
                           'has been made to be overly pedantic to avoid '
                           'destroying data. However, you should use caution, '
                           'maintain backups, and proceed at your own risk.')
        return rp

    def get_features(self):
        rf = chirp_common.RadioFeatures()
        rf.has_ctone = True
        rf.has_cross = True
        rf.has_tuning_step = False
        rf.has_settings = True
        rf.has_bank = False
        rf.has_sub_devices = True
        rf.has_dynamic_subdevices = True
        rf.has_rx_dtcs = True
        rf.can_odd_split = True
        rf.valid_tmodes = ['', 'Tone', 'TSQL', 'DTCS', 'Cross']
        rf.valid_cross_modes = ['Tone->Tone', 'DTCS->', '->DTCS', 'Tone->DTCS',
                                'DTCS->Tone', '->Tone', 'DTCS->DTCS']
        rf.valid_bands = self.VALID_BANDS
        rf.valid_modes = ['FM', 'NFM']
        rf.valid_tuning_steps = [2.5, 5.0, 6.25, 12.5, 10.0, 15.0, 20.0,
                                 25.0, 50.0, 100.0]
        rf.valid_duplexes = ['', '-', '+', 'split', 'off']
        rf.valid_power_levels = POWER_LEVELS
        rf.valid_name_length = 12
        rf.valid_characters = ('ABCDEFGHIJKLMNOPQRSTUVWXYZ'
                               'abcdefghijklmnopqrstuvwxyz'
                               '0123456789'
                               '!"#$%&\'()~+-,./:;<=>?@[\\]^`{}*| ')
        rf.memory_bounds = (1, 512)
        return rf

    @property
    def raw_zone(self):
        return getattr(self._memobj, 'zone%i' % self._zone)

    @property
    def raw_zoneinfo(self):
        return self.raw_zone.zoneinfo

    @property
    def raw_memories(self):
        return self.raw_zone.memories

    @property
    def max_mem(self):
        return self.raw_memories[self.raw_zoneinfo.count].number

    def _get_raw_memory(self, number):
        for i in range(0, self.raw_zoneinfo.count):
            if self.raw_memories[i].number == number:
                return self.raw_memories[i]
        return None

    def get_raw_memory(self, number):
        return repr(self._get_raw_memory(number))

    @staticmethod
    def _decode_tone(toneval):
        # DCS examples:
        # D024N - 2814 - 0010 1000 0001 0100
        #                  ^--DCS
        # D024I - A814 - 1010 1000 0001 0100
        #                ^----inverted
        # D754I - A9EC - 1010 1001 1110 1100
        #    code in octal-------^^^^^^^^^^^

        pol = toneval & 0x8000 and 'R' or 'N'
        if toneval == 0xFFFF:
            return '', None, None
        elif toneval & 0x2000:
            # DTCS
            code = int('%o' % (toneval & 0x1FF))
            return 'DTCS', code, pol
        else:
            return 'Tone', toneval / 10.0, None

    @staticmethod
    def _encode_tone(mode, val, pol):
        if not mode:
            return 0xFFFF
        elif mode == 'Tone':
            return int(val * 10)
        elif mode == 'DTCS':
            code = int('%i' % val, 8)
            code |= 0x2800
            if pol == 'R':
                code |= 0x8000
            return code
        else:
            raise errors.RadioError('Unsupported tone mode %r' % mode)

    def get_memory(self, number):
        mem = chirp_common.Memory()
        mem.number = number
        _mem = self._get_raw_memory(number)
        if _mem is None:
            mem.empty = True
            return mem

        mem.name = str(_mem.name).rstrip('\x00')
        mem.freq = int(_mem.rx_freq) * 10
        chirp_common.split_tone_decode(mem,
                                       self._decode_tone(_mem.tx_tone),
                                       self._decode_tone(_mem.rx_tone))
        if _mem.wide:
            mem.mode = 'FM'
        else:
            mem.mode = 'NFM'

        mem.power = POWER_LEVELS[_mem.highpower]

        offset = (int(_mem.tx_freq) - int(_mem.rx_freq)) * 10
        if _mem.tx_freq.get_raw() == b'\xFF\xFF\xFF\xFF':
            mem.offset = 0
            mem.duplex = 'off'
        elif offset == 0:
            mem.duplex = ''
            mem.offset


www.dealii.org/8.2.1/doxygen/deal.II/singletonFEEvaluation.html#af8861e1191d8fed585cebbc05f9a99d6',1,'FEEvaluationGL::FEEvaluation(const FEEvaluation &other)']]],
  ['feevaluationaccess',['FEEvaluationAccess',['http://www.dealii.org/8.2.1/doxygen/deal.II/classFEEvaluationAccess.html#a89294bb0dfa0045d1f93211e90a2e927',1,'FEEvaluation::FEEvaluationAccess(const MatrixFree< dim, Number > &matrix_free, const unsigned int fe_no, const unsigned int quad_no, const unsigned int fe_degree, const unsigned int n_q_points)'],['http://www.dealii.org/8.2.1/doxygen/deal.II/classFEEvaluationAccess.html#aa8e955ec0f75bf7c2ef9c17ef4eed5e8',1,'FEEvaluation::FEEvaluationAccess(const Mapping< dim > &mapping, const FiniteElement< dim > &fe, const Quadrature< 1 > &quadrature, const UpdateFlags update_flags, const unsigned int first_selected_component, const FEEvaluationBase< dim, n_components_other, Number > *other)'],['http://www.dealii.org/8.2.1/doxygen/deal.II/classFEEvaluationAccess.html#a2d5d22fa635c4c2a58bd78dae0df77e3',1,'FEEvaluation::FEEvaluationAccess(const FEEvaluationAccess &other)'],['http://www.dealii.org/8.2.1/doxygen/deal.II/classFEEvaluationAccess_3_011_00_011_00_01Number_01_4.html#acc2c1ac6b8e79b2ea5974c7175bf3e34',1,'FEEvaluationAccess< 1, 1, Number >::FEEvaluationAccess(const MatrixFree< 1, Number > &matrix_free, const unsigned int fe_no, const unsigned int quad_no, const unsigned int fe_degree, const unsigned int n_q_points)'],['http://www.dealii.org/8.2.1/doxygen/deal.II/classFEEvaluationAccess_3_011_00_011_00_01Number_01_4.html#a2176351805b776cddacd210d016103aa',1,'FEEvaluationAccess< 1, 1, Number >::FEEvaluationAccess(const Mapping< 1 > &mapping, const FiniteElement< 1 > &fe, const Quadrature< 1 > &quadrature, const UpdateFlags update_flags, const unsigned int first_selected_component, const FEEvaluationBase< 1, n_components_other, Number > *other)'],['http://www.dealii.org/8.2.1/doxygen/deal.II/classFEEvaluationAccess_3_011_00_011_00_01Number_01_4.html#ac0ad6018617cf6a7c906d1ac4eb6fe55',1,'FEEvaluationAccess< 1, 1, Number >::FEEvaluationAccess(const FEEvaluationAccess &other)'],['http://www.dealii.org/8.2.1/doxygen/deal.II/classFEEvaluationAccess_3_01dim_00_011_00_01Number_01_4.html#a3e4b9f6bdaa600ebe27a4fc63de14523',1,'FEEvaluationAccess< dim, 1, Number >::FEEvaluationAccess(const MatrixFree< dim, Number > &matrix_free, const unsigned int fe_no, cons


/panoptic_fpn_R_101_dconv_cascade_gn_3x/139797668/metrics.json">metrics

Mask R-CNN X152
0.234
15.1
50.2
44.0

18131413
model | metrics

above + test-time aug.

51.9
45.9

# LPToken

**Inherits:** Initializable, OwnableUpgradeable, [ILPToken](/src/interfaces/ILPToken.sol/interface.ILPToken.md)

**Author:** Nuts Finance Developer

ERC20 token minted by the StableSwap pools.

_LPToken is ERC20 rebase token minted by StableSwap pools for liquidity providers. LPToken balances are dynamic and
represent the holder's share in the total amount of lpToken controlled by the protocol. Account shares aren't
normalized, so the contract also stores the sum of all shares to calculate each account's token balance which equals to:
shares[account] _ \_totalSupply / \_totalShares where the \_totalSupply is the total supply of lpToken controlled by the
protocol.\*

## State Variables

### INFINITE_ALLOWANCE

_Constant value representing an infinite allowance._

```solidity
uint256 internal constant INFINITE_ALLOWANCE = ~uint256(0);
```

### BUFFER_DENOMINATOR

_Constant value representing the denominator for the buffer rate._

```solidity
uint256 public constant BUFFER_DENOMINATOR = 10 ** 10;
```

### totalShares

_The total amount of shares._

```solidity
uint256 public totalShares;
```

### totalSupply

_The total supply of lpToken_

```solidity
uint256 public totalSupply;
```

### totalRewards

_The total amount of rewards_

```solidity
uint256 public totalRewards;
```

### shares

_The mapping of account shares._

```solidity
mapping(address => uint256) public shares;
```

### allowances

_The mapping of account allowances._

```solidity
mapping(address => mapping(address => uint256)) public allowances;
```

### pools

_The mapping of pools._

```solidity
mapping(address => bool) public pools;
```

### bufferPercent

_The buffer rate._

```solidity
uint256 public bufferPercent;
```

### bufferAmount

_The buffer amount._

```solidity
uint256 public bufferAmount;
```

### tokenName

_The token name._

```solidity
string internal tokenName;
```

### tokenSymbol

_The token symbol._

```solidity
string internal tokenSymbol;
```

## Functions

### initialize

```solidity
function initialize(string memory _name, string memory _symbol) public initializer;
```

### transferShares

Moves `_sharesAmount` token shares from the caller's account to the `_recipient` account.

_The `_sharesAmount` argument is the amount of shares, not tokens._

```solidity
function transferShares(address _recipient, uint256 _sharesAmount) external returns (uint256);
```

**Returns**

| Name     | Type      | Description                                                                             |
| -------- | --------- | --------------------------------------------------------------------------------------- |
| `<none>` | `uint256` | amount of transferred tokens. E


sProvidedAsScheduledSinceLastReset(key []byte) [][]byte {
	gc.mutGasProvided.RLock()
	defer gc.mutGasProvided.RUnlock()
	return gc.txHashesWithGasProvidedAsScheduledSinceLastReset[string(key)]
}

func (gc *gasComputation) getTxHashesWithGasRefundedSinceLastReset(key []byte) [][]byte {
	gc.mutGasRefunded.RLock()
	defer gc.mutGasRefunded.RUnlock()
	return gc.txHashesWithGasRefundedSinceLastReset[string(key)]
}

func (gc *gasComputation) getTxHashesWithGasPenalizedSinceLastReset(key []byte) [][]byte {
	gc.mutGasPenalized.RLock()
	defer gc.mutGasPenalized.RUnlock()
	return gc.txHashesWithGasPenalizedSinceLastReset[string(key)]
}

// ComputeGasProvidedByMiniBlock computes gas provided by the given miniblock in sender and receiver shard
func (gc *gasComputation) ComputeGasProvidedByMiniBlock(
	miniBlock *block.MiniBlock,
	mapHashTx map[string]data.TransactionHandler,
) (uint64, uint64, error) {

	gasProvidedByMiniBlockInSenderShard := uint64(0)
	gasProvidedByMiniBlockInReceiverShard := uint64(0)

	for _, txHash := range miniBlock.TxHashes {
		txHandler, ok := mapHashTx[string(txHash)]
		if !ok {
			log.Debug("missing transaction in ComputeGasProvidedByMiniBlock ", "type", miniBlock.Type, "txHash", txHash)
			return 0, 0, process.ErrMissingTransaction
		}

		gasProvidedByTxInSenderShard, gasProvidedByTxInReceiverShard, err := gc.ComputeGasProvidedByTx(
			miniBlock.SenderShardID,
			miniBlock.ReceiverShardID,
			txHandler)
		if err != nil {
			return 0, 0, err
		}

		gasProvidedByMiniBlockInSenderShard += gasProvidedByTxInSenderShard
		gasProvidedByMiniBlockInReceiverShard += gasProvidedByTxInReceiverShard
	}

	return gasProvidedByMiniBlockInSenderShard, gasProvidedByMiniBlockInReceiverShard, nil
}

// ComputeGasProvidedByTx computes gas provided by the given transaction in sender and receiver shard
func (gc *gasComputation) ComputeGasProvidedByTx(
	txSenderShardId uint32,
	txReceiverShardId uint32,
	txHandler data.TransactionHandler,
) (uint64, uint64, error) {

	if check.IfNil(txHandler) {
		return 0, 0, process.ErrNilTransaction
	}

	isGasComputeV2FlagEnabled := gc.enableEpochsHandler.IsFlagEnabled(common.SCDeployFlag)
	if !isGasComputeV2FlagEnabled {
		return gc.computeGasProvidedByTxV1(txSenderShardId, txReceiverShardId, txHandler)
	}

	if txHandler.GetGasLimit() == 0 {
		return 0, 0, nil
	}

	moveBalanceConsumption := gc.economicsFee.ComputeGasLimit(txHandler)
	if moveBalanceConsumption > txHandler.GetGasLimit() {
		log.Trace("ComputeGasProvidedByTx less gasLimit than moveBalance", "gasLimit", txHandler.GetGasLimit(), "moveBalanceGasCost", moveBalanceConsumption)
		return txHandler.GetGasLimit(), txHandler.GetGasLimit(), nil
	}

	txTypeSndShard, txTypeDstShard, _ := gc.txTypeHandler.ComputeTransactionType(txHandler)
	isSCCall := txTypeDstShard == process.SCDeployment ||
		txTypeDstShard == process.SCInvoking ||
		txTypeDstShard == process.BuiltInFunctionCall
	if isSCCall {


       requestMarkDoneDto: RequestMarkDoneDto,
    ): Result<BadgeCardListEntity>

    suspend fun postUnCompleteCardId(
        pieceId: Int,
        requestMarkDoneDto: RequestMarkDoneDto,
    ): Result<Unit>
}
package com.napzak.market.core.designsystem.theme

import androidx.compose.runtime.Immutable
import androidx.compose.runtime.staticCompositionLocalOf
import androidx.compose.ui.graphics.Color

// Purple
val Purple10 = Color(0xFFF1E8FF)
val Purple20 = Color(0xFFC0A1FF)
val Purple30 = Color(0xFF7534FF)

// Pink
val Pink = Color(0xFFFF195E)

// Gray Scale & Gradient
val White = Color(0xFFFFFFFF)
val White0 = Color(0x00FFFFFF)
val White20 = Color(0x33FFFFFF)
val Gray50 = Color(0xFFFAFAFA)
val Gray100 = Color(0xFFF4F4F4)
val Gray200 = Color(0xFFE9E9E9)
val Gray300 = Color(0xFFD9D9D9)
val Gray400 = Color(0xFFC4C4C4)
val Gray500 = Color(0xFF9D9D9D)
val Gray600 = Color(0xFF7B7B7B)
val Gray700 = Color(0xFF555555)
val Gray800 = Color(0xFF434343)
val Gray900 = Color(0xFF262626)
val Black = Color(0xFF010101)
val Black70 = Color(0xB3000000)

@Immutable
data class NapzakMarketColors(
    // Purple
    val purple10: Color,
    val purple20: Color,
    val purple30: Color,

    // Pink
    val pink: Color,

    // Gray Scale & Gradient
    val white: Color,
    val white0: Color,
    val white20: Color,
    val gray50: Color,
    val gray100: Color,
    val gray200: Color,
    val gray300: Color,
    val gray400: Color,
    val gray500: Color,
    val gray600: Color,
    val gray700: Color,
    val gray800: Color,
    val gray900: Color,
    val black: Color,
    val black70: Color
)

val defaultNapzakMarketColors = NapzakMarketColors(
    // Purple
    purple10 = Purple10,
    purple20 = Purple20,
    purple30 = Purple30,

    // Pink
    pink = Pink,

    // Gray Scale & Gradient
    white = White,
    white0 = White0,
    white20 = White20,
    gray50 = Gray50,
    gray100 = Gray100,
    gray200 = Gray200,
    gray300 = Gray300,
    gray400 = Gray400,
    gray500 = Gray500,
    gray600 = Gray600,
    gray700 = Gray700,
    gray800 = Gray800,
    gray900 = Gray900,
    black = Black,
    black70 = Black70
)

val localNapzakMarketColors = staticCompositionLocalOf { defaultNapzakMarketColors }
package com.napzak.market.core.designsystem.component.button

import androidx.compose.foundation.layout.PaddingValues
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material3.Button
import androidx.compose.material3.ButtonColors
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.unit.dp
import com.napzak.market.core.common.util.NoRippleInteractionSource

/**
 * 기본 텍스트 버튼 컴포넌트
 *
 * @param text 버튼에 표시될 텍스트
 * @param onClick 버튼 클릭 시 수행할 동작
 * @param shape 버튼의 모서리 모양
 * @param textStyle 버튼 텍스트의 스타일
 * @param isEnabled 버튼 활성화 여부
 */

@Composable
fun CommonButton(
    text: String,
    onClick: () -> Unit,
    buttonColors: ButtonColors,
    shape: RoundedCornerShape,
    textStyle: TextStyle,
    modifier


s(MeshFactory meshFactory, int sectionCount, Point2d[] crossSection,
            int crossCount) {

        Vector2d[] crossSectionSoftNormals = calsSoftNormals(crossSection);

        int[][] softNormalsIntex = new int[sectionCount][];
        for (int i = 0; i < sectionCount; i++) {
            double a = Math.toRadians(360) / sectionCount * i;

            SimpleMatrix rotY = TransformationMatrix3d.rotYA(a);
            softNormalsIntex[i] = new int[crossCount];

            for (int j = 0; j < crossSection.length; j++) {
                // point
                Vector2d n2d = crossSectionSoftNormals[j];
                Vector3d n = new Vector3d(n2d.x, n2d.y, 0);

                Vector3d transform = TransformationMatrix3d.transform(n, rotY);

                int in = meshFactory.addNormal(transform);
                softNormalsIntex[i][j] = in;
            }
        }
        return softNormalsIntex;
    }

    private static Vector2d[] calsSoftNormals(Point2d[] crossSection) {

        Vector2d[] ret = new Vector2d[crossSection.length];

        Vector2d[] normals = new Vector2d[crossSection.length - 1];
        for (int i = 0; i < crossSection.length - 1; i++) {
            Vector2d n = new Vector2d(crossSection[i + 1]);
            n.sub(crossSection[i]);
            n.normalize();
            normals[i] = n;
        }

        for (int i = 1; i < crossSection.length - 1; i++) {
            Vector2d n1 = normals[i - 1];
            Vector2d n2 = normals[i];

            Vector2d n = Vector2dUtil.bisectorNormalized(n1, n2);
            n.normalize();

            ret[i] = n;
        }

        ret[0] = Vector2dUtil.orthogonalLeft(normals[0]);

        ret[crossSection.length - 1] = Vector2dUtil.orthogonalLeft(normals[normals.length - 1]);

        for (Vector2d element : ret) {
            element.negate();
        }

        return ret;
    }

    private static TextureQuadIndex[] buildRotaryShapeTextureMapping(MeshFactory meshFactory, int crossCount, int sectionCount,
            Point3d[][] mesh) {
        // texture mapping only for one section, all others are the same
        int i = 0;

        return buildTextureMappingForCross(meshFactory, mesh, sectionCount, crossCount, i);
    }

    private static Vector3d calcNormal(Point3d p1, Point3d p2, Point3d p3) {
        Vector3d n = new Vector3d(p2);
        n.sub(p1);

        Vector3d n2 = new Vector3d(p3);
        n2.sub(p2);

        n.cross(n, n2);
        n.normalize();
        return n;
    }

    public static TextureQuadIndex[] buildTextureMappingForCross(MeshFactory meshFactory, Point3d[][] mesh, int pointCount,
            int crossCount, int i) {

        TextureQuadIndex[] crossTc = new TextureQuadIndex[crossCount];

        double textHeightDown = 0;

        Point3d[] c1 = mesh[i];
        Point3d[] c2 = mesh[(i + 1) % pointCount];

        Point3d middleDown = new Point3d((c1[0].x + c2[0].x) / 2d, (c1[0].y + c2[0].y) / 2d, (c1[0].z + c2[0].z) / 2d);

        double widthDown = middleDown.distance(c2[0]);

        for (int j = 1; j < crossCount; j++) {

            Point3d middleTop = new Point3d((c1[j].x + c2[j].


namespace GraphQL.DataLoader;

/// <summary>
/// A data loader that returns a list of values for each given unique key
/// </summary>
/// <typeparam name="TKey">The type of the key</typeparam>
/// <typeparam name="T">The type of the return value</typeparam>
public class CollectionBatchDataLoader<TKey, T> : DataLoaderBase<TKey, IEnumerable<T>>
    where TKey : notnull
{
    private readonly Func<IEnumerable<TKey>, CancellationToken, Task<ILookup<TKey, T>>> _loader;

    /// <summary>
    /// Initializes a new instance of CollectionBatchDataLoader with the specified fetch delegate
    /// </summary>
    /// <param name="fetchDelegate">An asynchronous delegate that is passed a list of keys and cancellation token, which returns an ILookup of keys and values</param>
    /// <param name="keyComparer">An optional equality comparer for the keys</param>
    /// <param name="maxBatchSize">The maximum number of keys passed to the fetch delegate at a time</param>
    public CollectionBatchDataLoader(Func<IEnumerable<TKey>, CancellationToken, Task<ILookup<TKey, T>>> fetchDelegate,
           IEqualityComparer<TKey>? keyComparer = null,
           int maxBatchSize = int.MaxValue) : base(keyComparer, maxBatchSize)
    {
        _loader = fetchDelegate ?? throw new ArgumentNullException(nameof(fetchDelegate));
    }

    /// <summary>
    /// Initializes a new instance of CollectionBatchDataLoader with the specified fetch delegate and key selector
    /// </summary>
    /// <param name="fetchDelegate">An as


_android_7_0_31_fe0f_20e3);
        EMOTICONS.put("2⃣", R.drawable.emoji_android_7_0_32_fe0f_20e3);
        EMOTICONS.put("3⃣", R.drawable.emoji_android_7_0_33_fe0f_20e3);
        EMOTICONS.put("4⃣", R.drawable.emoji_android_7_0_34_fe0f_20e3);
        EMOTICONS.put("5⃣", R.drawable.emoji_android_7_0_35_fe0f_20e3);
        EMOTICONS.put("6⃣", R.drawable.emoji_android_7_0_36_fe0f_20e3);
        EMOTICONS.put("7⃣", R.drawable.emoji_android_7_0_37_fe0f_20e3);
        EMOTICONS.put("8⃣", R.drawable.emoji_android_7_0_38_fe0f_20e3);
        EMOTICONS.put("9⃣", R.drawable.emoji_android_7_0_39_fe0f_20e3);
        EMOTICONS.put("🆎", R.drawable.emoji_android_7_0_1f18e);
        EMOTICONS.put("🅱", R.drawable.emoji_android_7_0_1f171);
        EMOTICONS.put("🆑", R.drawable.emoji_android_7_0_1f191);
        EMOTICONS.put("🆓", R.drawable.emoji_android_7_0_1f193);
        EMOTICONS.put("🆔", R.drawable.emoji_android_7_0_1f194);
        EMOTICONS.put("🆕", R.drawable.emoji_android_7_0_1f195);
        EMOTICONS.put("🆖", R.drawable.emoji_android_7_0_1f196);
        EMOTICONS.put("🅾", R.drawable.emoji_android_7_0_1f17e);
        EMOTICONS.put("🆗", R.drawable.emoji_android_7_0_1f197);
        EMOTICONS.put("🆘", R.drawable.emoji_android_7_0_1f198);
        EMOTICONS.put("🆙", R.drawable.emoji_android_7_0_1f199);
        EMOTICONS.put("🆚", R.drawable.emoji_android_7_0_1f19a);
        EMOTICONS.put("▪", R.drawable.emoji_android_7_0_25aa);
        EMOTICONS.put("▫", R.drawable.emoji_android_7_0_25ab);
        EMOTICONS.put("◻", R.drawable.emoji_android_7_0_25fb);
        EMOTICONS.put("◼", R.drawable.emoji_android_7_0_25fc);
        EMOTICONS.put("◽", R.drawable.emoji_android_7_0_25fd);
        EMOTICONS.put("◾", R.drawable.emoji_android_7_0_25fe);
        EMOTICONS.put("⬛", R.drawable.emoji_android_7_0_2b1b);
        EMOTICONS.put("⬜", R.drawable.emoji_android_7_0_2b1c);
        EMOTICONS.put("🔶", R.drawable.emoji_android_7_0_1f536);
        EMOTICONS.put("🔷", R.drawable.emoji_android_7_0_1f537);
        EM


import pandas as pd

def create_session_table(conn) -> None:
    query = """
    CREATE TABLE sessions AS
    WITH user_events AS (
        SELECT
            userId,
            movieId,
            timestamp,
            ROW_NUMBER() OVER (
                PARTITION BY userId
                ORDER BY timestamp
            ) AS seq
        FROM ratings
    )
    SELECT
        userId,
        movieId,
        timestamp,
        seq,
        CASE
            WHEN LAG(timestamp) OVER (
                PARTITION BY userId
                ORDER BY timestamp
            ) IS NULL
            OR (
                timestamp - LAG(timestamp) OVER (
                    PARTITION BY userId
                    ORDER BY timestamp
                )
            ) > 1800
            THEN 1
            ELSE 0
        END AS new_session
    FROM user_events;
    """
    conn.execute(query)
    print("Session table created with sessionization logic.")

def sessionize_events(conn) -> pd.DataFrame:
    query = """
    SELECT
        userId,
        movieId,
        timestamp,
        SUM(new_session) OVER (
            PARTITION BY userId
            ORDER BY timestamp
            ROWS UNBOUNDED PRECEDING
        ) AS session_id
    FROM sessions;
    """
    result = conn.execute(query).fetchdf()
    return result

def create_user_metrics(conn) -> None:
    query = """
    CREATE TABLE user_metrics AS
    SELECT userId, COUNT(*) AS rating_count, AVG(rating) AS avg_rating
    FROM ratings
    GROUP BY userId;
    """
    conn.execute(query)
    print("User metrics table created.")

def create_user_recency(conn) -> None:
    query = """
    CREATE TABLE user_recency AS
    SELECT userId, MAX(timestamp) AS last_interaction
    FROM ratings
    GROUP BY userId;
    """
    conn.execute(query)
    print("User recency table created.")


gemm_1_1GemmCoord.html#a93515a41db6c4b7e9101067f60d41b8c">m() ||

   72     grid_tiled_shape.n() <= tb_tile_offset.n()) {

   73

   74     return;

   75   }

   76

   77   // Compute initial location in logical coordinates

   78   cutlass::MatrixCoord tb_offset_A{

   79     tb_tile_offset.m() * Mma::Shape::kM,

   80     tb_tile_offset.k()

   81   };

   82

   83   cutlass::MatrixCoord tb_offset_B{

   84     tb_tile_offset.k(),

   85     tb_tile_offset.n() * Mma::Shape::kN

   86   };

   87

<span


ds */

  interval = 2 * (interval / GST_USECOND);

  return interval;
}

static gint64
gst_mss_demux_stream_get_fragment_waiting_time (GstAdaptiveDemuxStream * stream)
{
  /* Wait a second for live streams so we don't try premature fragments downloading */
  return GST_SECOND;
}

static GstFlowReturn
gst_mss_demux_update_manifest_data (GstAdaptiveDemux * demux,
    GstBuffer * buffer)
{
  GstMssDemux *mssdemux = GST_MSS_DEMUX_CAST (demux);

  gst_mss_demux_update_base_url (mssdemux);

  gst_mss_manifest_reload_fragments (mssdemux->manifest, buffer);
  return GST_FLOW_OK;
}

static gboolean
gst_mss_demux_get_live_seek_range (GstAdaptiveDemux * demux, gint64 * start,
    gint64 * stop)
{
  GstMssDemux *mssdemux = GST_MSS_DEMUX_CAST (demux);

  return gst_mss_manifest_get_live_seek_range (mssdemux->manifest, start, stop);
}

static GstFlowReturn
gst_mss_demux_data_received (GstAdaptiveDemux * demux,
    GstAdaptiveDemuxStream * stream, GstBuffer * buffer)
{
  GstMssDemux *mssdemux = GST_MSS_DEMUX_CAST (demux);
  GstMssDemuxStream *mssstream = (GstMssDemuxStream *) stream;
  gsize available;

  if (!gst_mss_manifest_is_live (mssdemux->manifest)) {
    return GST_ADAPTIVE_DEMUX_CLASS (parent_class)->data_received (demux,
        stream, buffer);
  }

  if (gst_mss_stream_fragment_parsing_needed (mssstream->manifest_stream)) {
    gst_mss_manifest_live_adapter_push (mssstream->manifest_stream, buffer);
    available =
        gst_mss_manifest_live_adapter_available (mssstream->manifest_stream);
    // FIXME: try to reduce this minimal size.
    if (available < 4096) {
      return GST_FLOW_OK;
    } else {
      GST_LOG_OBJECT (stream->pad, "enough data, parsing fragment.");
      buffer =
          gst_mss_manifest_live_adapter_take_buffer (mssstream->manifest_stream,
          available);
      gst_mss_stream_parse_fragment (mssstream->manifest_stream, buffer);
    }
  }

  return GST_ADAPTIVE_DEMUX_CLASS (parent_class)->data_received (demux, stream,
      buffer);
}

static gboolean
gst_mss_demux_requires_periodical_playlist_update (GstAdaptiveDemux * demux)
{
  return TRUE;
}


>

SetChecksum
2
2
This field is mandatory and Section 7.4.3 defines its contents.

FileAttributes
4
2
This field is mandatory and Section 7.4.4 defines its contents.

Reserved1
6
2
This field is mandatory and its contents are reserved.

CreateTimestamp
8
4
This field is mandatory and Section 7.4.5 defines its contents.

LastModifiedTimestamp
12
4
This field is mandatory and Section 7.4.6 defines its contents.

LastAccessedTimestamp
16
4
This field is mandatory and Section 7.4.7 defines its contents.

Create10msIncrement
20
1
This field is mandatory and Section 7.4.5 defines its contents.

LastModified10msIncrement
21
1
This field is mandatory and Section 7.4.6 defines its contents.

CreateUtcOffset
22
1
This field is mandatory and Section 7.4.5 defines its contents.

LastModifiedUtcOffset
23
1
This field is mandatory and Section 7.4.6 defines its contents.

LastAccessedUtcOffset
24
1
This field is mandatory and Section 7.4.7 defines its contents.

Reserved2
25
7
This field is mandatory and its contents are reserved.

#### 7.4.1 EntryType Field

The EntryType field shall conform to the definition provided in the Generic Primary DirectoryEntry template (see [Section 6.3.1](#631-entrytype-field)).

##### 7.4.1.1 TypeCode Field

The TypeCode field shall conform to the definition provided in the Generic Primary DirectoryEntry template (se


rses to Genesis 1:1 in Hebrews \n e.g. write a summary on Exodus 13 \n e.g. compare Mark 1 and John 1",
    "exportChat": "Export Chat",
    "countPromptTokens": "Count Prompt Tokens",
    "pluginDirectory": "Plugins Directory",
    "textSelection": "Text Selection",
    "webBrowser": "Web Browser",
    "runAsSystemCommand": "Run as System Command",
    "runAsPythonCommand": "Execute as Python Script",
    "plugins": "Plugins",
    "chatAfterFunctionCalled": "Chat with Function Response",
    "runPythonScriptGlobally": "Run Python Script Globally",
    "readTextFile": "Read Text File",
    "customise": "Customise",
    "donate": "Donate",
    "about": "About",
    "githubStatistics": "GitHub Statistics",
    "overrideCompareToUseAllTexts": "Override verse comparison to compare all Bible texts instead of favorite texts",
    "downloadGCloudModulesInSeparateThread": "Downloads the Marvel GCloud (Non-GitHub) modules in a separate thread",
}


es = table{
	'^t_tt',
	'^t_ti',
	--Gamma^t_it = Gamma^t_ti
	'^i_tt',
	'^i_mt',
	--Gamma^i_tm = Gamma^i_mt
	'^t_im',
	'^i_mn',
}
local GammasForIndexes = table()

--[[
TODO until my index simplification gets better I don't think there will be a "one size fits all" for this
might be better to handle each subset individually
--]]
for _,index in ipairs(indexes) do
	local indexLetters = index:gsub('[^%a]', '')

	print'<hr>'

	local expr = Gamma(index)
	printbr(expr)

	printbr'factor out index raise'
	expr = expr:replaceIndex(Gamma'^a_bc', g'^ad' * Gamma'_dbc')
	printbr(expr)

	printbr'substitute definition of connection'
	-- same as above
	-- expr = indexExprReplace(expr, Gamma'_abc', frac(1,2) * (g'_ab,c' + g'_ac,b' - g'_bc,a'))
	expr = expr:replaceIndex(Gamma'_abc', frac(1,2) * (g'_ab,c' + g'_ac,b' - g'_bc,a'))()
	printbr(expr)

	-- TODO this causes overlapped indexes later
	printbr'split the index a into t and j'
	expr = splitIndex(expr, 'a', {'t', 'j'})()
	printbr(expr)

	printbr'replace ADM metric definitions'
	expr = expr:splitOffDerivIndexes()

-- TODO replaceIndex fails on _tt ... but not _ti ... strange
	expr = expr:replace(g'_tt', -alpha^2 + beta'^k' * beta'^l' * gamma'_kl')

	expr = expr:replace(g'_tj', beta'_j')
	expr = expr:replace(g'_jt', beta'_j')
	expr = expr:replaceIndex(g'_ij', gamma'_ij')

	expr = expr:replace(g'^tt', -1/alpha^2)

	expr = expr:replaceIndex(g'^ti', beta'_i' / alpha^2)
	expr = expr:replaceIndex(g'^it', beta'_i' / alpha^2)
	expr = expr:replaceIndex(g'^ij', gamma'^ij' - beta'^i' * beta'^j' / alpha^2)

	printbr(expr)

	printbr'raise $\\beta_j$'

	expr = expr:replaceIndex(beta'_j,t':splitOffDerivIndexes(), (g'_jk' * beta'^k')'_,t')
	expr = expr:replaceIndex(g'_jk', gamma'_jk')
	expr = expr:replaceIndex(beta'_t,t':splitOffDerivIndexes(), (g'_tk' * beta'^k')'_,t')
	expr = expr:replaceIndex(g'_tk', gamma'_kl' * beta'^l')
	printbr(expr)

	printbr'simplify...'
	expr = expr:simplifyAddMulDiv()
	printbr(expr)

	-- TODO some kind of tensor-friendly :prune() or :simplify()
	-- that keeps track of sum terms, and relabels them in some canonical form, and simplifies accordingly ?
	printbr'relabel...'

	expr = replaceSubExpr(expr, -beta'^i' * gamma'_kl,t' * beta'^k' * beta'^l',
								-beta'^i' * beta'^j' * beta'^k' * gamma'_jk,t')
			:simplifyAddMulDiv()
	printbr(expr)

	GammasForIndexes[index] = expr

	printbr('for ', beta'^i':eq(0))

	expr = replaceForAnyIndex(expr, beta'^i', 0)()
	printbr(expr)
end

-- ok now Riemann
local indexes = table{
	--R^t_ttt = 0
	'^t_tti',
	--R^t_tit = -R^t_tti
	--R^t_itt = 0
	--R^i_ttt = 0
	'^t_tij',
	'^t_itj',
	'^i_ttj',
	--R^t_ijt = -R^t_itj
	--R^i_tjt = -R^i_ttj
	--R^i_jtt = 0
	'^t_ijk',
	'^i_tjk',
	'^i_jtk',
	--R^i_jkt = -R^i_jtk
	'^i_jkl',
}

for _,index in ipairs(indexes) do
	local indexLetters = index:gsub('[^%a]', '')

	print


sbbq	%rax, %rax
# CHECK-NEXT: [1,1]     D==eeeeER   mulxq	%rax, %rax, %rax

# CHECK:      Average Wait times (based on the timeline view):
# CHECK-NEXT: [0]: Executions
# CHECK-NEXT: [1]: Average time spent waiting in a scheduler's queue
# CHECK-NEXT: [2]: Average time spent waiting in a scheduler's queue while ready
# CHECK-NEXT: [3]: Average time elapsed from WB until retire stage

# CHECK:            [0]    [1]    [2]    [3]
# CHECK-NEXT: 0.     2     1.5    0.5    1.5       sbbq	%rax, %rax
# CHECK-NEXT: 1.     2     2.5    0.0    0.0       mulxq	%rax, %rax, %rax
# CHECK-NEXT:        2     2.0    0.3    0.8       <total>

# CHECK:      [2] Code Region

# CHECK:      Iterations:        1000
# CHECK-NEXT: Instructions:      3000
# CHECK-NEXT: Total Cycles:      4004
# CHECK-NEXT: Total uOps:        4000

# CHECK:      Dispatch Width:    6
# CHECK-NEXT: uOps Per Cycle:    1.00
# CHECK-NEXT: IPC:               0.75
# CHECK-NEXT: Block RThroughput: 1.0

# CHECK:      Instruction Info:
# CHECK-NEXT: [1]: #uOps
# CHECK-NEXT: [2]: Latency
# CHECK-NEXT: [3]: RThroughput
# CHECK-NEXT: [4]: MayLoad
# CHECK-NEXT: [5]: MayStore
# CHECK-NEXT: [6]: HasSideEffects (U)

# CHECK:      [1]    [2]    [3]    [4]    [5]    [6]    Instructions:
# CHECK-NEXT:  2      4     1.00                        mulxl	%eax, %eax, %eax
# CHECK-NEXT:  1      0     0.17                        cmpl	%eax, %eax
# CHECK-NEXT:  1      1     0.50                        cmovael	%eax, %ecx

# CHECK:      Resources:
# CHECK-NEXT: [0]   - Zn3AGU0
# CHECK-NEXT: [1]   - Zn3AGU1
# CHECK-NEXT: [2]   - Zn3AGU2
# CHECK-NEXT: [3]   - Zn3ALU0
# CHECK-NEXT: [4]   - Zn3ALU1
# CHECK-NEXT: [5]   - Zn3ALU2
# CHECK-NEXT: [6]   - Zn3ALU3
# CHECK-NEXT: [7]   - Zn3BRU1
# CHECK-NEXT: [8]   - Zn3FPP0
# CHECK-NEXT: [9]   - Zn3FPP1
# CHECK-NEXT: [10]  - Zn3FPP2
# CHECK-NEXT: [11]  - Zn3FPP3
# CHECK-NEXT: [12.0] - Zn3FPP45
# CHECK-NEXT: [12.1] - Zn3FPP45
# CHECK-NEXT: [13]  - Zn3FPSt
# CHECK-NEXT: [14.0] - Zn3LSU
# CHECK-NEXT: [14.1] - Zn3LSU
# CHECK-NEXT: [14.2] - Zn3LSU
# CHECK-NEXT: [15.0] - Zn3Load
# CHECK-NEXT: [15.1] - Zn3Load
# CHECK-NEXT: [15.2] - Zn3Load
# CHECK-NEXT: [16.0] - Zn3Store
# CHECK-NEXT: [16.1] - Zn3Store

# CHECK:      Resource pressure per iteration:
# CHECK-NEXT: [0]    [1]    [2]    [3]    [4]    [5]    [6]    [7]    [


InstId\":\"polardbx-storage-1-master\"},{\"group\":\"D1_000004_GROUP\","
        + "\"schema\":\"d1_000004\",\"storageInstId\":\"polardbx-storage-0-master\"}],\"schema\":\"d1\"}}";

    String CREATE_D1_T1 = "{\"logicTableMeta\":{\"phySchemas\":[{\"group\":\"D1_000000_GROUP\","
        + "\"phyTables\":[\"t1_TRwG_00\",\"t1_TRwG_01\"],\"schema\":\"d1_000000\","
        + "\"storageInstId\":\"polardbx-storage-0-master\"},{\"group\":\"D1_000001_GROUP\","
        + "\"phyTables\":[\"t1_TRwG_02\",\"t1_TRwG_03\"],\"schema\":\"d1_000001\","
        + "\"storageInstId\":\"polardbx-storage-1-master\"},{\"group\":\"D1_000002_GROUP\","
        + "\"phyTables\":[\"t1_TRwG_04\",\"t1_TRwG_05\"],\"schema\":\"d1_000002\","
        + "\"storageInstId\":\"polardbx-storage-0-master\"},{\"group\":\"D1_000003_GROUP\","
        + "\"phyTables\":[\"t1_TRwG_06\",\"t1_TRwG_07\"],\"schema\":\"d1_000003\","
        + "\"storageInstId\":\"polardbx-storage-1-master\"},{\"group\":\"D1_000004_GROUP\","
        + "\"phyTables\":[\"t1_TRwG_08\",\"t1_TRwG_09\"],\"schema\":\"d1_000004\","
        + "\"storageInstId\":\"polardbx-storage-0-master\"},{\"group\":\"D1_000005_GROUP\","
        + "\"phyTables\":[\"t1_TRwG_10\",\"t1_TRwG_11\"],\"schema\":\"d1_000005\","
        + "\"storageInstId\":\"polardbx-storage-1-master\"},{\"group\":\"D1_000006_GROUP\","
        + "\"phyTables\":[\"t1_TRwG_12\",\"t1_TRwG_13\"],\"schema\":\"d1_000006\","
        + "\"storageInstId\":\"polardbx-storage-0-master\"},{\"group\":\"D1_000007_GROUP\","
        + "\"phyTables\":[\"t1_TRwG_14\",\"t1_TRwG_15\"],\"schema\":\"d1_000007\","
        + "\"storageInstId\":\"polardbx-storage-1-master\"}],\"tableName\":\"t1\",\"tableType\":1}}";

    String MOVE_D1_0001_0 = "{\"logicDbMeta\":{\"logicTableMetas\":[],\"phySchemas\":[{\"group\":\"D1_SINGLE_GROUP\","
        + "\"schema\":\"d1_single\",\"storageInstId\":\"polardbx-storage-0-master\"},{\"group\":\"D1_000006_GROUP\","
        + "\"schema\":\"d1_000006\",\"storageInstId\":\"polardbx-storage-0-master\"},{\"group\":\"D1_000003_GROUP\","
        + "\"schema\":\"d1_000003\",\"storageInstId\":\"polardbx-storage-1-master\"},{\"group\":\"D1_000005_GROUP\","
        + "\"schema\":\"d1_000005\",\"storageInstId\":\"polardbx-storage-1-master\"},{\"group\":\"D1_000002_GROUP\","
        + "\"schema\":\"d1_000002\",\"storageInstId\":\"polardbx-storage-0-master\"},{\"group\":\"D1_000000_GROUP\","
        + "\"schema\":\"d1_000000\",\"st


 "abcd", false))
	assert.Equal(t, 0, comparePublisher("abcd", "ABCD", false))
	assert.Equal(t, 0, comparePublisher("ABCD", "abcd", true))
	assert.Equal(t, 0, comparePublisher("abcd", "ABCD", true))

	assert.Equal(t, 0, comparePublisher("", "abcd", false))
	assert.Equal(t, 0, comparePublisher("abcd", "", false))

	assert.Equal(t, -1, comparePublisher("", "abcd", true))
	assert.Equal(t, 1, comparePublisher("abcd", "", true))
}

func unsortedA() []ApplicationData {
	return []ApplicationData{
		{Name: "zyx", Version: "1.0.0", ApplicationType: "1", Architecture: "A"},
		{Name: "zyx", Version: "2.0.0", ApplicationType: "2", Architecture: "B"},
		{Name: "yxw", Version: "2.0.0", ApplicationType: "3", Architecture: "C"},
		{Name: "yxw", Version: "1.0.0", ApplicationType: "4", Architecture: "D"},
		{Name: "xwv", Version: "1.0.0", ApplicationType: "5", Architecture: "E"},
		{Name: "abc", Version: "2.0.0", ApplicationType: "6", Architecture: "F"},
		{Name: "def", Version: "2.0.0", ApplicationType: "7", Architecture: "G"},
	}
}

func unsortedB() []ApplicationData {
	return []ApplicationData{
		{Name: "abc", Version: "2.0.0", ApplicationType: "A", URL: "1"},
		{Name: "zyx", Version: "1.0", ApplicationType: "B", URL: "2"},
		{Name: "yxw", Version: "1.0.1", ApplicationType: "C", URL: "3"},
		{Name: "xwv", Version: "1.0", ApplicationType: "D", URL: "4"},
		{Name: "zyxwv", Version: "2.0.0", ApplicationType: "E", URL: "5"},
		{Name: "def", Version: "2.0.0", ApplicationType: "F", URL: "6"},
		{Name: "def", Version: "2.0", ApplicationType: "G", URL: "7"},
	}
}

func unsortedC() []ApplicationData {
	return []ApplicationData{
		{Name: "4", Version: "1.0.0"},
		{Name: "3", Version: "1.0.0"},
	}
}

func unsortedD() []ApplicationData {
	return []ApplicationData{
		{Name: "2", Version: "1.0.0"},
		{Name: "1", Version: "1.0.0"},
	}
}

func mergedCD() []ApplicationData {
	return []ApplicationData{
		{Name: "1", Version: "1.0.0"},
		{Name: "2", Version: "1.0.0"},
		{Name: "3", Version: "1.0.0"},
		{Name: "4", Version: "1.0.0"},
	}
}

func unsortedE() []ApplicationData {
	return []ApplicationData{
		{Name: "1", Publisher: "A", Version: "1.0.0", URL: "a"},
		{Name: "1", Publisher: "B", Version: "1.0.0", URL: "b"},
	}
}

func unsortedF() []ApplicationData {
	return []ApplicationData{
		{Name: "1", Publisher: "b", Version: "1.0.0", URL: "c"},
		{Name: "1", Version: "1.0.0", URL: "d"},
	}
}

func mergedEF() []ApplicationData {
	return []ApplicationData{
		{Name: "1", Publisher: "A", Version: "1.0.0", URL: "a"},
		{Name:


6vfcVbgudgpYCADs=)}.mce-visualblocks ul{background-image:url(data:image/gif;base64,R0lGODlhDQAKAIAAALu7u////yH5BAEAAAEALAAAAAANAAoAAAIXjI8GybGuYnqUVSjvw26DzzXiqIDlVwAAOw==)}.mce-visualblocks ol{background-image:url(data:image/gif;base64,R0lGODlhDQAKAIABALu7u////yH5BAEAAAEALAAAAAANAAoAAAIXjI8GybH6HHt0qourxC6CvzXieHyeWQAAOw==)}.mce-visualblocks dl{background-image:url(data:image/gif;base64,R0lGODlhDQAKAIABALu7u////yH5BAEAAAEALAAAAAANAAoAAAIXjI8GybEOnmOvUoWznTqeuEjNSCqeGRUAOw==)}.mce-visualblocks:not([dir=rtl]) address,.mce-visualblocks:not([dir=rtl]) article,.mce-visualblocks:not([dir=rtl]) aside,.mce-visualblocks:not([dir=rtl]) blockquote,.mce-visualblocks:not([dir=rtl]) div:not([data-mce-bogus]),.mce-visualblocks:not([dir=rtl]) dl,.mce-visualblocks:not([dir=rtl]) figcaption,.mce-visualblocks:not([dir=rtl]) figure,.mce-visualblocks:not([dir=rtl]) h1,.mce-visualblocks:not([dir=rtl]) h2,.mce-visualblocks:not([dir=rtl]) h3,.mce-visualblocks:not([dir=rtl]) h4,.mce-visualblocks:not([dir=rtl]) h5,.mce-visualblocks:not([dir=rtl]) h6,.mce-visualblocks:not([dir=rtl]) hgroup,.mce-visualblocks:not([dir=rtl]) ol,.mce-visualblocks:not([dir=rtl]) p,.mce-visualblocks:not([dir=rtl]) pre,.mce-visualblocks:not([dir=rtl]) section,.mce-visualblocks:not([dir=rtl]) ul{margin-left:3px}.mce-visualblocks[dir=rtl] address,.mce-visualblocks[dir=rtl] article,.mce-visualblocks[dir=rtl] aside,.mce-visualblocks[dir=rtl] blockquote,.mce-visualblocks[dir=rtl] div:not([data-mce-bogus]),.mce-visualblocks[dir=rtl] dl,.mce-visualblocks[dir=rtl] figcaption,.mce-visualblocks[dir=rtl] figure,.mce-visualblocks[dir=rtl] h1,.mce-visualblocks[dir=rtl] h2,.mce-visualblocks[dir=rtl] h3,.mce-visualblocks[dir=rtl] h4,.mce-visualblocks[dir=rtl] h5,.mce-visualblocks[dir=rtl] h6,.mce-visualblocks[dir=rtl] hgroup,.mce-visualblocks[dir=rtl] ol,.mce-visualblocks[dir=rtl] p,.mce-visualblocks[dir=rtl] pre,.mce-visualblocks[dir=rtl] section,.mce-visualblocks[dir=rtl] ul{background-position-x:right;margin-right:3px}.mce-nbsp,.mce-shy{background:#aaa}.mce-shy::after{content:'-'}
body.tox-dialog__disable-scroll {
  overflow: hidden;
}
.tox-fullscreen {
  border: 0;
  height: 100%;
  margin: 0;
  overflow: hidden;
  overscroll-behavior: none;
  padding: 0;
  touch-action: pinch-zoom;
  width: 100%;
}
.tox.tox-tinymce.tox-fullscreen .tox-statusbar__resize-handle {
  display: none;
}
.tox.tox-tinymce.tox-fullscreen,
.tox-shadowhost.tox-fullscreen {
  left: 0;
  position: fixed;
  top: 0;
  z-index: 1200;
}
.tox.tox-tinymc


1.78.1">
<link rel="home" href="../../../../index.html" title="Chapter 1. Geometry">
<link rel="up" href="../register.html" title="Macro's for adaption">
<link rel="prev" href="boost_geometry_register_linestring.html" title="BOOST_GEOMETRY_REGISTER_LINESTRING">
<link rel="next" href="boost_geometry_register_multi_linestring.html" title="BOOST_GEOMETRY_REGISTER_MULTI_LINESTRING">

Home
Libraries
People
FAQ
More

BOOST_GEOMETRY_REGISTER_LINESTRING_TEMPLATED

Macro to register a templated linestring.

            Description

            The macro BOOST_GEOMETRY_REGISTER_LINESTRING_TEMPLATED registers a templated
            linestring such that it is recognized by Boost.Geometry and that Boost.Geometry
            functionality can used with the specified type. The type must have one
            template parameter, which should be a point type, and should not be specified.
            Boost.Geometry takes care of inserting the template parameter. Hence
            all types of this templated linestring are registered, regardless of
            their point type.

            <a name="geometry.reference.adapted.register.boost_geometry_register_linestring_templated


r:
			newqv = types.QValueQChar{Val: uint8(v)}
		case lua.LString:
			if len(v) > 0 {
				newqv = types.QValueQChar{Val: v[0]}
			}
		default:
			ls.RaiseError("invalid \"char\"")
		}
	case types.QValueKindString:
		newqv = types.QValueString{Val: lua.LVAsString(val)}
	case types.QValueKindEnum:
		newqv = types.QValueEnum{Val: lua.LVAsString(val)}
	case types.QValueKindTimestamp:
		newqv = types.QValueTimestamp{Val: LVAsTime(ls, val)}
	case types.QValueKindTimestampTZ:
		newqv = types.QValueTimestampTZ{Val: LVAsTime(ls, val)}
	case types.QValueKindDate:
		newqv = types.QValueDate{Val: LVAsTime(ls, val)}
	case types.QValueKindTime:
		newqv = types.QValueTime{Val: LVAsDuration(ls, val)}
	case types.QValueKindTimeTZ:
		newqv = types.QValueTimeTZ{Val: LVAsDuration(ls, val)}
	case types.QValueKindInterval:
		newqv = types.QValueInterval{Val: lua.LVAsString(val)}
	case types.QValueKindNumeric:
		newqv = types.QValueNumeric{Val: LVAsDecimal(ls, val)}
	case types.QValueKindBytes:
		newqv = types.QValueBytes{Val: []byte(lua.LVAsString(val))}
	case types.QValueKindUUID:
		if ud, ok := val.(*lua.LUserData); ok {
			if id, ok := ud.Value.(uuid.UUID); ok {
				newqv = types.QValueUUID{Val: id}
			}
		}
	case types.QValueKindArrayUUID:
		if tbl, ok := val.(*lua.LTable); ok {
			newqv = types.QValueArrayUUID{
				Val: shared.LTableToSlice(ls, tbl, func(_ *lua.LState, v lua.LValue) uuid.UUID {
					return uuid.MustParse(lua.LVAsString(v))
				}),
			}
		}
	case types.QValueKindJSON:
		newqv = types.QValueJSON{Val: lua.LVAsString(val)}
	case types.QValueKindArrayFloat32:
		if tbl, ok := val.(*lua.LTable); ok {
			newqv = types.QValueArrayFloat32{
				Val: shared.LTableToSlice(ls, tbl, func(_ *lua.LState, v lua.LValue) float32 {
					return float32(lua.LVAsNumber(v))
				}),
			}
		}
	case types.QValueKindArrayFloat64:
		if tbl, ok := val.(*lua.LTable); ok {
			newqv = types.QValueArrayFloat64{
				Val: shared.LTableToSlice(ls, tbl, func(_ *lua.LState, v lua.LValue) float64 {
					return float64(lua.LVAsNumber(v))
				}),
			}
		}
	case types.QValueKindArrayInt16:
		if tbl, ok := val.(*lua.LTable); ok {
			newqv = types.QValueArrayFloat64{
				Val: shared.LTableToSlice(ls, tbl, func(_ *lua.LState, v lua.LValue) float64 {
					return float64(lua.LVAsNumber(v))
				}),
			}
		}
	case types.QValueKindArrayInt32:
		if tbl, ok := val.(*lua.LTable); ok {
			newqv = types.QValueArrayFloat64{
				Val: shared.LTableToSlice(ls, tbl, func(_ *lua.LState,


K
            VGnrtSOmLChgcn6r5OKmHbq8yzcWwlO20+8UZaDXAXwx1/y6DZ2yx8BinAGDNo65
            q0+V3Wv6fCIURn61Vpw=
            """.trimIndent().replace("\n", "")
        val certBinary = Base64.decode(certString)

        val cert = certBinary.toSecCertificate()
        val byteArray = cert.toByteArray()
        assertContentEquals(certBinary, byteArray)
    }
}
/*
 * Copyright 2022-2023 Jeff Lockhart
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package kotbase

public actual open class DataSource
private constructor(
    internal val source: Collection,
    protected var alias: String? = null
) {

    public actual class As
    internal constructor(collection: Collection) : DataSource(collection) {

        public actual infix fun `as`(alias: String): DataSource {
            this.alias = alias
            return this
        }
    }

    internal fun asJSON(): Map<String, Any?> {
        return buildMap {
            put("COLLECTION", source.fullName)
            if (alias != null) {
                put("AS", alias)
            }
        }
    }

    public actual companion object {

        @Deprecated(
            "Use DataSource.collection(Collection)",
            ReplaceWith("collection(database.defaultCollection)")
        )
        public actual fun database(database: Database): As =
            As(database.defaultCollection).apply {
                `as`(database.name)
            }

        public actual fun collection(collection: Collection): As =
            As(collection)
    }
}
/*
 * Copyright 2022-2023 Jeff Lockhart
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package kotbase

import kotbase.ext.toStringMillis
import kotbase.util.identityHashCodeHex
import kotlinx.datetime.Instant

public actual open class Expression {

    private class ValueExpression(private val value: Any?) : Expression() {

        init {
            verifySupportedType(value)
        }

        override fun asJSON(): Any? =
            asJSON(value)

        @Suppress("UNCHECKED_CAST")
        private fun asJSON(value: Any?): Any? = when (value) {
            is Instant -> value.toStringMillis()
            is Map<*, *> -> mapAsJSON(value as Map<String, Any?>)
            is List<*> -> listAsJSON(value)
            is Expression -> value.asJSON()
            else -> {
                verifySupportedType(value)
                value
            }
        }

        private fun mapAsJSON(map: Map<String, Any?>): Any =
            map.mapValues { asJSON(it.value) }

        private fun listAsJSON(list: List<Any?>): Any {
            return buildList {
                add("[]") // Array Operation
                list.forEach {
                    add(asJSON(it))
                }
            }
        }

        private fun verifySupportedType(value: Any?) {
            if (value == null
                || value is String
                || value is Number // including int, long, float, double
                || value is Boolean
                || valu


-for-dom-permissionstate-granted⑦">"granted",
        <var>descriptorB</var>’s permission state must also be "granted", and
        if <var>descriptorB</var>’s permission state is "denied",
        <var>descriptorA</var>’s permission state must also be "denied".

        {name: <u class="link-error" data-lt=""midi"" title="LINK ERROR: Ambiguous for-less link for '"midi"', please see <https://speced.github.io/bikeshed/#ambi-for> for instructions:
Local references:
spec:permissions; type:enum-value; for:PermissionName; text:"midi"
for-less references:
spec:webmidi; type:permission; for:/; text:"midi"
spec:webmidi; type:permission; for:/; text:"midi"">"midi", sysex: true} ("midi-with-sysex") is
        stronger than {name: <u class="link-error" data-lt=""midi"" title="LINK ERROR: Ambiguous for-less link for '"midi"', please see <https://speced.github.io/bikeshed/#ambi-for> for instructions:
Local references:
spec:permissions; type:enum-value; for:PermissionName; text:"midi"
for-less references:
spec:webmidi; type:permission; for:/; text:"midi"
spec:webmidi; type:permission; for:/; text:"midi"">"midi", sysex: false}
        ("midi-without-sysex"), so if the user denies access to
        midi-without-sysex, the UA must also deny access to midi-with-sysex, and
        similarly if the user grants access to midi-with-sysex, the UA must also
        grant access to midi-without-sysex.

Optional <dfn class="dfn-paneled" data-dfn-type="dfn" data-export id="permission-state-constraints">permission state constraints</dfn>

      Constraints on the values that the UA can return as a descriptor’s
      permission state. Defaults to no constraints beyond the user’s
      intent.

      An optional <dfn class="dfn-paneled" data-dfn-type="dfn" data-export id="extra-permission-data-type">extra permissio


:outputString);
        outputString("");
    }

    private static void addNewNote(Scanner userInput, List<String> notes) {
        var noteText = readStringWithPrompt(userInput, "Введите текст заметки...");
        var finalNoteText = LocalDateTime.now() + " | " + noteText;
        notes.add(finalNoteText);
    }

    private static void checkNoteNumber(int noteNumber, List<String> notes) {
        if (noteNumber <= 0 || noteNumber > notes.size()) {
            throw new NoteIndexOutOfBoundsException("Given number of note is out of range");
        }
    }

    private static void updateNote(Scanner userInput, List<String> notes) {
        var updatedNoteNumber = readIntWithPrompt(userInput, "Введите номер изменяемой заметки...");
        checkNoteNumber(updatedNoteNumber, notes);

        var noteText = readStringWithPrompt(userInput, "Введите текст заметки...");
        var finalNoteText = LocalDateTime.now() + " | " + noteText;
        notes.set(updatedNoteNumber - 1, finalNoteText);
    }

    private static void deleteNote(Scanner userInput, List<String> notes) {
        var deletedNoteNumber = readIntWithPrompt(userInput, "Введите номер удаляемой заметки...");
        checkNoteNumber(deletedNoteNumber, notes);

        notes.remove(deletedNoteNumber - 1);
    }

    private static void outputString(String s){
        System.out.println(s);
    }

    private static int readInt(Scanner userInput){
        return Integer.parseInt(userInput.nextLine());
    }

    private static int readIntWithPrompt(Scanner userInput, String prompt){
        outputString(prompt);
        return Integer.parseInt(userInput.nextLine());
    }

    private static String readStringWithPrompt(Scanner userInput, String prompt){
        outputString(prompt);
        return userInput.nextLine();
    }
}
package ru.otus.spring.rest;

import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import ru.otus.spring.domain.Person;
import ru.otus.spring.domain.PersonDto;
import ru.otus.spring.repository.PersonRepository;

@RestController
public class PersonController {

    private final PersonRepository repository;

    public PersonController(PersonRepository repository) {
        this.repository = repository;
    }

    @GetMapping("/person")
    public Flux<PersonDto> all() {
        return repository.findAll()
                .map(this::toDto);
    }

    @GetMapping("/person/{id}")
    public Mono<ResponseEntity<PersonDto>> byId(@PathVariable("id") String id) {
        return repository.findById(id)
                .map(this::toDto)
                .map(ResponseEntity::ok)
                .switchIfEmpty(Mono.fromCallable(() -> ResponseEntity.notFound().build()));
    }

    @PostMapping("/person")
    public Mono<Person> save(@RequestBody Mono<Person> dto) {
        return repository.save(dto);
    }

    @GetMapping("/person/find")
    public Flux<Person> byName(@RequestParam("name") String name) {
        return repository.findAllByLastName(name);
    }

    private PersonDto toDto(Person person) {
        return new PersonDto(person.getId(), person.getLastName(), person.getAge());
    }
}
package ru.otus.springdata;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.data.domain.Example;
import org.springframework.


 &VSE::SiteEvent<I, F>,
        site2: &VSE::SiteEvent<I, F>,
        site3: &VSE::SiteEvent<I, F>,
        segment_index: SiteIndex,
    ) -> bool {
        #[allow(clippy::suspicious_operation_groupings)]
        if segment_index != SiteIndex::Two {
            let orient1 =
                OrientationTest::<I, F>::eval_p(site1.point0(), site2.point0(), site3.point0());
            let orient2 =
                OrientationTest::<I, F>::eval_p(site1.point0(), site2.point0(), site3.point1());
            if segment_index == SiteIndex::One && site1.x0() >= site2.x0() {
                if orient1 != Orientation::Right {
                    return false;
                }
            } else if segment_index == SiteIndex::Three && site2.x0() >= site1.x0() {
                if orient2 != Orientation::Right {
                    return false;
                }
            } else if orient1 != Orientation::Right && orient2 != Orientation::Right {
                return false;
            }
        } else {
            return (site3.point0() != site1.point0()) || (site3.point1() != site2.point0());
        }
        true
    }

    #[inline(always)]
    fn pss(
        site1: &VSE::SiteEvent<I, F>,
        site2: &VSE::SiteEvent<I, F>,
        site3: &VSE::SiteEvent<I, F>,
        point_index: SiteIndex,
    ) -> bool {
        if site2.sorted_index() == site3.sorted_index() {
            return false;
        }
        if point_index == SiteIndex::Two {
            if !site2.is_inverse() && site3.is_inverse() {
                return false;
            }
            if site2.is_inverse() == site3.is_inverse()
                && OrientationTest::<I, F>::eval_p(site2.point0(), site1.point0(), site3.point1())
                    != Orientation::Right
            {
                return false;
            }
        }
        true
    }

    pub(crate) fn sss(
        site1: &VSE::SiteEvent<I, F>,
        site2: &VSE::SiteEvent<I, F>,
        site3: &VSE::SiteEvent<I, F>,
    ) -> bool {
        (site1.sorted_index() != site2.sorted_index())
            && (site2.sorted_index() != site3.sorted_index())
    }
}

#[derive(Default)]
pub struct LazyCircleFormationFunctor<I, F>
where
    I: InputType,
    F: OutputType,
{
    #[doc(hidden)]
    pdf_: PhantomData<F>,
    #[doc(hidden)]
    pdi_: PhantomData<I>,
}

#[allow(non_snake_case)]
impl<I, F> LazyCircleFormationFunctor<I, F>
where
    I: InputType,
    F: OutputType,
{
    /// Lazy evaluation of point, point, point circle events
    fn ppp(poin


, RaftStateDump, RequestVoteRequest,
    RequestVoteResponse, RpcMessage, RpcRequest, RpcResponse,
};
use crate::util::{sleep, Sleep};
use crate::webrtc_rpc::transport::{self, Client, PeerTransport};
use futures::channel::mpsc::{channel, Receiver, Sender, UnboundedSender};
use futures::channel::oneshot;
use futures::select;
use futures::sink::SinkExt;
use futures::stream::StreamExt;
use rand::{thread_rng, Rng};
use std::cmp::{max, min};
use std::collections::{HashMap, HashSet};
use std::fmt::Debug;
use std::ops::RangeInclusive;
use std::time::Duration;
use wasm_bindgen_futures::spawn_local;

const HEARBEAT_INTERVAL_MILLIS: u64 = 100;

enum RaftWorkerState<Cmd> {
    Follower(RaftWorker<Follower, Cmd>),
    Candidate(RaftWorker<Candidate, Cmd>),
    Leader(RaftWorker<Leader<Cmd>, Cmd>),
}

struct RaftWorker<S, Cmd> {
    inner: RaftWorkerInner<Cmd>,
    state: S,
}

#[derive(Debug)]
struct Follower {}
#[derive(Debug)]
struct Candidate {}
struct Leader<Cmd> {
    next_indices: HashMap<NodeId, LogIndex>,
    match_indices: HashMap<NodeId, LogIndex>,
    in_flight_client_requests: Box<HashMap<LogIndex, oneshot::Sender<ClientResult<Cmd>>>>,
    in_flight_peers: HashSet<NodeId>,
    responses_tx: Sender<InFlightResponse<Cmd>>,
    responses_rx: Option<Receiver<InFlightResponse<Cmd>>>,
}

impl<Cmd> Debug for Leader<Cmd> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("Leader")
            .field("next_indices", &self.next_indices)
            .field("match_indices", &self.match_indices)
            .field("in_flight_peers", &self.in_flight_peers)
            .finish()
    }
}

type RpcClient<Cmd> = Client<RpcRequest<Cmd>, RpcResponse<Cmd>>;
type RpcResult<Cmd> = Result<RpcResponse<Cmd>, transport::Error>;
type ClientResult<Cmd> = Result<ClientResponse<Cmd>, ClientError>;
type InFlightResponse<Cmd> = (NodeId, RangeInclusive<LogIndex>, RpcResult<Cmd>);

enum StateChange {
    Continue,
    BecomeFollower,
}

struct RaftWorkerInner<Cmd> {
    leader_id: Option<NodeId>,
    node_id: NodeId,
    session_key: u128,
    cluster_size: usize,
    client_rx: Receiver<ClientMessage<Cmd>>,
    rpc_rx: Receiver<RpcMessage<Cmd>>,
    rpc_server: RpcServer<Cmd>,
    peers_rx: Receiver<PeerTransport>,
    state_machine_tx: UnboundedSender<Cmd>,

    // Peers is constant throughout the runtime (regardless of whether they're
    // online or not)
    peers: Vec<NodeId>,
    // Peer clients could connect/disconnect
    peer_clients: HashMap<NodeId, RpcClient<Cmd>>,

    // Volatile state
    commit_index: LogIndex,
    last_applied: LogIndex,

    // Persistent state
    storage: Storage<Cmd>,
}

impl<Cmd> RaftWorkerState<Cmd>
where
    Cmd: Command,
{
    async fn next(self) -> Self {
        match self {
            RaftWorkerState::Follower(worker) => worker.next().await,
            RaftWorkerState::Candidate(worker) => worker.next().await,
            RaftWorkerState::Leader(worker) => worker.next().await,
        }
    }
}

pub struct WorkerBuilder<Cmd> {
    pub node_id: NodeId,
    pub session_key: u128,
    pub peers: Vec<NodeId>,
    p


n-go_gapic. DO NOT EDIT.

// [START datacatalog_v1_generated_PolicyTagManager_UpdateTaxonomy_sync]

package main

import (
	"context"

	datacatalog "cloud.google.com/go/datacatalog/apiv1"
	datacatalogpb "cloud.google.com/go/datacatalog/apiv1/datacatalogpb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := datacatalog.NewPolicyTagManagerClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &datacatalogpb.UpdateTaxonomyRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/datacatalog/apiv1/datacatalogpb#UpdateTaxonomyRequest.
	}
	resp, err := c.UpdateTaxonomy(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

// [END datacatalog_v1_generated_PolicyTagManager_UpdateTaxonomy_sync]
// Copyright 2025 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// Code generated by protoc-gen-go_gapic. DO NOT EDIT.

// [START datacatalog_v1_generated_PolicyTagManager_SetIamPolicy_sync]

package main

import (
	"context"

	datacatalog "cloud.google.com/go/datacatalog/apiv1"
	iampb "cloud.google.com/go/iam/apiv1/iampb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := datacatalog.NewPolicyTagManagerClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &iampb.SetIamPolicyRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/iam/apiv1/iampb#SetIamPolicyRequest.
	}
	resp, err := c.SetIamPolicy(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

// [END datacatalog_v1_generated_PolicyTagManager_SetIamPolicy_sync]
// Copyright 2025 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS


}, {
					id = "XEng0OilHose0",
					plenum = 0.001,
					skin = "Rubber",
					wall = 0.032
				}, {
					id = "XEng0OilRadiator0",
					plenum = 0.88,
					skin = "Steel",
					wall = 0.006
				}, {
					id = "XEng0OilHose1",
					plenum = 0.001,
					skin = "Rubber",
					wall = 0.032
				}, {
					id = "XEng0OilRadiator1",
					plenum = 0.88,
					skin = "Steel",
					wall = 0.006
				}, {
					id = "XEng0Carburettor",
					skin = "Aluminum",
					wall = 0.015
				}, {
					count = 4,
					id = "XJoint11",
					skin = "Aluminum",
					wall = 0.006
				}, {
					count = 4,
					id = "XJoint2",
					skin = "Aluminum",
					wall = 0.006
				}, {
					count = 4,
					id = "XJoint4",
					skin = "Aluminum",
					wall = 0.006
				}, {
					count = 4,
					id = "XJoint9",
					skin = "Aluminum",
					wall = 0.006
				} }
		},
		[137] = {
			args = { 151 },
			children = { 3 },
			construction = {
				durability = 1.97,
				skin = "Aluminum"
			},
			critical_damage = 3,
			damage_boundary = 0.03,
			droppable = false,
			failures = { { "INST_VARIOMETER_DEPRESSURIZATION", 0.01 }, { "INST_VARIOMETER_CLOGGED", 0.01 }, { "INST_SPEEDOMETER_DEPRESSURIZATION", 0.01 }, { "INST_DI_EXCESSIVE_DRIFT", 0.01 }, { "INST_DI_MECHANICAL_FAILURE", 0.01 }, { "INST_TACH0_LOOM_SEVERED", 0.01 }, { "INST_TACH0_POOR_CONNECTION", 0.01 }, { "INST_TACH0_RESISTANCE_MISMATCH", 0.01 }, { "INST_TACH1_LOOM_SEVERED", 0.01 }, { "INST_TACH1_POOR_CONNECTION", 0.01 }, { "INST_TACH1_RESISTANCE_MISMATCH", 0.01 }, { "INST_HUD_FAILURE", 0.01 }, { "INST_COMPASS_MALFUNCTION", 0.01 }, { "INST_CLOCK_MALFUNCTION", 0.01 }, { "HORIZON_BAR_NOT_SETTLE", 0.01 }, { "TURNIND_POINTER_FAILS_NO_VACUUM", 0.01 }, { "TURNIND_POINTER_FAILS_DEFECTIVE", 0.01 }, { "TURNIND_INCORRECT_SENS_DEFECTIVE", 0.01 }, { "TURNIND_INCORRECT_SENS_VAC_HIGH", 0.01 }, { "TURNIND_INCORRECT_SENS_VAC_LOW", 0.01 }, { "TURNIND_POINTER_NOT_SET_ZERO", 0.01 }, { "TURNIND_POINTER_VIBRATES", 0.01 }, { "ELEC_RETICLE_BULB_FAILURE", 0.01 }, { "K14_NO_POWER_SUPPLY", 0.01 }, { "K14_FIXED_LAMP_DEFECTIVE", 0.01 }, { "K14_MOV_LAMP_DEFECTIVE", 0.01 }, { "K14_MOTOR_DEFECTIVE", 0.01 } }
		},
		[138] = {
			args = { 296 },
			construction = {
				durability = 0.84,
				skin = "


; i < 6; i++ {
					if err := pubsubs[i].WaitForDeliveries(5 * time.Second); err != nil {
						t.Logf("Node %d: %v", i+1, err)
					}
				}
				t.Log("All nodes have seen all proposals, proceeding")
				break loop
			}

			// Log current state
			for i := 0; i < 6; i++ {
				state := engines[i].GetState()
				mu.Lock()
				t.Logf("Engine %d state: %v, proposals: %d, votes: %d, liveness: %d",
					i+1, state, proposalCount[i], voteCount[i], livenessCount[i])
				mu.Unlock()
			}
		}
	}

	// Give time for voting and finalization
	time.Sleep(10 * time.Second)

	// Check states after consensus
	for i := 0; i < 6; i++ {
		state := engines[i].GetState()
		mu.Lock()
		t.Logf("Final Engine %d state: %v, proposals: %d, votes: %d",
			i+1, state, proposalCount[i], voteCount[i])
		mu.Unlock()
	}

	// Check if any frames were published
	mu.Lock()
	totalFrames := 0
	for i := 0; i < 6; i++ {
		totalFrames += len(allFrames[i])
	}
	mu.Unlock()

	t.Logf("Total frames published across all nodes: %d", totalFrames)

	// Stop all engines
	for i := 0; i < 6; i++ {
		close(quits[i])
		<-engines[i].Stop(false)
	}
}

func TestGlobalConsensusEngine_Integration_ShardCoverage(t *testing.T) {
	engine, _, _, cleanup := createIntegrationTestGlobalConsensusEngine(t, []byte{0x03}, 99)
	defer cleanup()

	// Track emitted events
	var publishedEvents []tconsensus.ControlEvent
	var mu sync.Mutex

	// Replace event distributor to capture events
	eventDistributor := events.NewGlobalEventDistributor(nil)

	// Subscribe to capture events
	eventCh := eventDistributor.Subscribe("test")
	go func() {
		for event := range eventCh {
			mu.Lock()
			publishedEvents = append(publishedEvents, event)
			mu.Unlock()
			t.Logf("Event published: %d", event.Type)
		}
	}()

	engine.eventDistributor = eventDistributor

	// Start the event distributor
	engine.Start(make(chan struct{}))

	// Configure low coverage scenario in hypergraph
	// Since we registered only 1 prover above, this is already a low coverage scenario

	// Run shard coverage check
	err := engine.checkShardCoverage()
	require.NoError(t, err)

	// Wait for event processing
	time.Sleep(100 * time.Millisecond)

	// Stop the event distributor
	eventDistributor.Stop()
}

// TestGlobalConsensusEngine_Integration_NoProversStaysInVerifying tests that engines
// remain in the verifying state when no provers are registered in the hypergraph
func TestGlobalConsensusEngine_Integration_NoProversStaysInVerifying(t *testing.T) {
	t.Log("Testing global consensus engines with no registered provers")

	// Create shared components
	logger, _ := zap.NewDevelopment()

	// Create six nodes
	numNodes := 6
	engines := make([]*GlobalConsensusEngine, numNodes)
	pubsubs := make([]*mockIntegrationPubSub, numNodes)
	quits := make([]chan struct{}, numNodes)

	// Create shared hypergraph with NO provers registered
	inclusionProver := bls48581.NewKZGInclusionProver(logger)
	verifiableEncryptor := verenc.NewMPCitHVerifiableEncryptor(1)

	// Create separate hypergraph


te is at an epoch other than periapse the
   fragment below will NOT produce a "correct" type 15 segment
   for modeling the motion of your object.)

      #include "SpiceUsr.h"
          .
          .
          .

      /.
      First we get the osculating elements.
      /
      oscelt_c ( state, epoch, gm, elts );

      /.
      From these collect the eccentricity and semi-latus rectum.
      ./
      ecc = elts [ 1 ];
      p   = elts [ 0 ] * ( 1.0 + ecc );

      /.
      Next get the trajectory pole vector and the
      periapsis vector.
      ./
      ucrss_c ( state, state+4, tp );
      vhat_c  ( state,          pa );

      /.
      Enable both J2 corrections.
      ./
      j2flg = 0.0;

      /.
      Now add the segment.
      ./
      spkw15_c ( handle,  body,   center,  frame,  first,  last,
                 segid,   epoch,  tp,      pa,     p,      ecc,
                 j2flg,   pv,     gm,      j2,     radius       );

-Restrictions

   None.

-Literature_References

   None.

-Author_and_Institution

   N.J. Bachman    (JPL)
   W.L. Taber      (JPL)

-Version

   -CSPICE Version 1.0.1, 29-MAY-2012 (NJB)

      Header was updated to relect changes in handling
      of inputs `tp', `pa', and `pv' by the f2c'd routine
      spkw15_. That routine now writes unit length
      versions of these vectors to the output segment.

      A header comment typo was corrected.

   -CSPICE Version 1.0.0, 21-JUN-1999 (WLT)

-Index_Entries

   Write a type 15 spk segment

-&
*/

{ /* Begin spkw15_c */

   /*
   Local constants
   */

   /*
   Local macros
   */

   /*
   Local variables
   */

   /*
   Static variables
   */

   /*
   Participate in error tracing.
   */

   chkin_c ( "spkw15_c" );

   /*
   Check the input strings to make sure the pointers
   are non-null and the string lengths are non-zero.
   */
   CHKFSTR ( CHK_STANDARD, "spkw15_c", frame );
   CHKFSTR ( CHK_STANDARD, "spkw15_c", segid );

   /*
   Write the segment.
   */
   spkw15_ ( ( integer    * ) &handle,
             ( integer    * ) &body,
             ( integer    * ) &center,
             ( char       * ) frame,
             ( doublereal * ) &first,
             ( doublereal * ) &last,
             ( char       * ) segid,
             ( doublereal * ) &epoch,
             ( doublereal * ) tp,
             ( doublereal * ) pa,
             ( doublereal * ) &p,
             ( doublereal * ) &ecc,
             ( doublereal * ) &j2flg,
             ( doublereal * ) pv,
             ( doublereal * ) &gm,
             ( doublereal * ) &j2,
             ( doublereal * ) &radius,
             ( ftnlen       ) strlen(frame),
             ( ftnlen       ) strlen(segid)  );

   chkout_c ( "spkw15_c" );

} /* End spkw15_c */


e.UtcNow;
            Description = description;
            OrganizationId = budget.OrganizationId;
            FinancialAccountId = budget.Identity;
            FinancialAccountName = budget.Name; // redundancy in case of future name changes
            OwnerPersonId = budget.OwnerPersonId;
            OwnerPersonName = budget.OwnerPersonId != 0 ? budget.Owner.Name : string.Empty;
            ActingPersonId = creatingPerson.Identity; // do not save name for data retention reasons
            BeneficiaryPersonId = 0;
            Supplier = supplier;
        }

        public string Supplier { get; set; }
    }
}


 a random number generator.
pub trait Rng: Clone {
	/// The byte output that this RNG emits.
	type Output: AsRef<[u8]>;

	/// Generates a random sequence of bytes, seeding from the internal state.
	fn rand(&mut self) -> Self::Output;
	/// Generates a random sequence of bytes, with a custom seed.
	fn rand_with_seed(seed: &[u8]) -> Self::Output;
	/// Generates a random of the specified type, seeding from the internal state.
	fn generate<R>(&mut self) -> R
	where
		R: RandomGen<Self>,
	{
		R::random(self)
	}
	/// Fill an array with the specified type.
	fn fill<R, A>(&mut self, mut target: A)
	where
		R: RandomGen<Self>,
		A: AsMut<[R]>,
	{
		let target = target.as_mut();
		target.iter_mut().for_each(|entry| *entry = self.generate());
	}
	/// Generates a random of the specified type, seeding from the internal state.
	fn generate_range<R, B>(&mut self, range: B) -> R
	where
		R: RandomRange<Self>,
		B: RangeBounds<R>,
	{
		R::random_range(self, range)
	}
	/// Shuffle a slice, using the RNG.
	fn shuffle<I, S>(&mut self, mut target: S)
	where
		S: AsMut<[I]>,
	{
		let target = target.as_mut();
		let target_len = target.len();
		for idx in 0..target_len {
			let random_idx = self.generate_range(0..target_len);
			target.swap(idx, random_idx);
		}
	}
	/// Reseeds the RNG using a custom seed.
	fn reseed(&mut self, new_seed: &[u8]);
}
fn main() {
    let contents = include_str!("day01.txt");
    println!(
        "{}",
        contents
            .lines()
            .map(|x| x.parse::<i32>().unwrap())
            .sum::<i32>()
    );
}
fn main() {
    let mut x = 5;
    println!("x is {}", x);

    x = 6;
    println!("now x is {}", x);

    const Y: i32 = 9;
    println!("constant Y is {}", Y);

    let z = 12;
    let z = z + 1;
    println!("z is {}", z);

    // let mut m = "hello";
    // m = 9;
    //     16 |     m = 9;
    //    |         ^ expected &str, found integral variable

    let va :i32 = "21".parse().expect("what is this");
    println!("va is {}", va);
}
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
pub fn serialize_structure_crate_input_associate_channel_flow_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::AssociateChannelFlowInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_1) = &input.channel_flow_arn {
        object.key("ChannelFlowArn").string(var_1);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_batch_create_channel_membership_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::BatchCreateChannelMembershipInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_2) = &input.member_arns {
        let mut array_3 = object.key("MemberArns").start_array();
        for item_4 in var_2 {
            {
                array_3.value().string(item_4);


ump.
      if (Pred->succ_size() == 1)
        FallThruCost += ScaleBlockFrequency(EdgeFreq, JumpInstCost);
      HeaderFallThroughCost = std::max(HeaderFallThroughCost, FallThruCost);
    }
  }

  // Here we collect all exit blocks in the loop, and for each exit we find out
  // its hottest exit edge. For each loop rotation, we define the loop exit cost
  // as the sum of frequencies of exit edges we collect here, excluding the exit
  // edge from the tail of the loop chain.
  SmallVector<std::pair<MachineBasicBlock *, BlockFrequency>, 4> ExitsWithFreq;
  for (auto BB : LoopChain) {
    auto LargestExitEdgeProb = BranchProbability::getZero();
    for (auto *Succ : BB->successors()) {
      BlockChain *SuccChain = BlockToChain[Succ];
      if (!LoopBlockSet.count(Succ) &&
          (!SuccChain || Succ == *SuccChain->begin())) {
        auto SuccProb = MBPI->getEdgeProbability(BB, Succ);
        LargestExitEdgeProb = std::max(LargestExitEdgeProb, SuccProb);
      }
    }
    if (LargestExitEdgeProb > BranchProbability::getZero()) {
      auto ExitFreq = MBFI->getBlockFreq(BB) * LargestExitEdgeProb;
      ExitsWithFreq.emplace_back(BB, ExitFreq);
    }
  }

  // In this loop we iterate every block in the loop chain and calculate the
  // cost assuming the block is the head of the loop chain. When the loop ends,
  // we should have found the best candidate as the loop chain's head.
  for (auto Iter = LoopChain.begin(), TailIter = std::prev(LoopChain.end()),
            EndIter = LoopChain.end();
       Iter != EndIter; Iter++, TailIter++) {
    // TailIter is used to track the tail of the loop chain if the block we are
    // checking (pointed by Iter) is the head of the chain.
    if (TailIter == LoopChain.end())
      TailIter = LoopChain.begin();

    auto TailBB = *TailIter;

    // Calculate the cost by putting this BB to the top.
    BlockFrequency Cost = 0;

    // If the current BB is the loop header, we need to take into account the
    // cost of the missed fall through edge from outside of the loop to the
    // header.
    if (Iter != LoopChain.begin())
      Cost += HeaderFallThroughCost;

    // Collect the loop exit cost by summing up frequencies of all exit edges
    // except the one from the chain tail.
    for (auto &ExitWithFreq : ExitsWithFreq)
      if (TailBB != ExitWithFreq.first)
        Cost += ExitWithFreq.second;

    // The cost of breaking the once fall-through edge from the tail to the top
    // of the loop chain. Here we need to consider three cases:
    // 1. If the tail node has only one successor, then we will get an
    //    additional jmp instruction. So the cost here is (MisfetchCost +
    //    JumpInstCost) * tail node frequency.
    // 2. If the tail node has two successors, then we may still get an
    //    additional jmp instruction if the layout successor after the loop
    //    chain is not its CFG successor. Note that the more frequently executed
    //    jmp instruction will be put ahead of the other one. Assume the
    //    frequency of those two branches are x and y, where x is the frequency
    //    of the edge to the chain head, then the cost will be
    //    (x * MisfetechCost + min(x, y) * JumpInstCost) * tail node frequency.
    // 3. If the tail node has more than two successors (this rarely happens),
    //    we won't consider any additional cost.
    if (TailBB->isSuccessor(*Iter)) {
      auto TailBBFreq = MBFI->getBlockFreq(TailBB);
      if (TailBB->succ_size() == 1)
        Cost += ScaleBlockFrequency(TailBBFreq.getFrequency(),


2_ta1x8x1x1_1x4x1x64_tb1x8x4x1_1x4x1x64_vs1_gkgs_mfma_finishing
    s_waitcnt lgkmcnt(0)
    s_barrier
    ds_read_b64 v[v_a:v_a+1], v[v_sld_a_os]
    ds_read_b64 v[v_b:v_b+1], v[v_sld_b_os]
    v_mfma_f32_32x32x8f16 a[a_c+32:a_c+47], v[v_a+6:v_a+7], v[v_b+4:v_b+5], a[a_c+32:a_c+47]     ; repeat:1x0, step:0x0, num_a_c:16
    ds_read_b64 v[v_b+2:v_b+2+1], v[v_sld_b_os] offset:2048
    ds_read_b64 v[v_a+2:v_a+2+1], v[v_sld_a_os] offset:512
    v_mfma_f32_32x32x8f16 a[a_c+48:a_c+63], v[v_a+6:v_a+7], v[v_b+6:v_b+7], a[a_c+48:a_c+63]     ; repeat:1x1, step:0x0, num_a_c:16
    s_branch L_igemm_fwd_gtcx_nhwc_fp16_bx0_ex0_bt64x256x32_wt32x32x8_ws1x1_wr2x2_ta1x8x1x1_1x4x1x64_tb1x8x4x1_1x4x1x64_vs1_gkgs_mfma_body
L_igemm_fwd_gtcx_nhwc_fp16_bx0_ex0_bt64x256x32_wt32x32x8_ws1x1_wr2x2_ta1x8x1x1_1x4x1x64_tb1x8x4x1_1x4x1x64_vs1_gkgs_mfma_finishing:
    v_mfma_f32_32x32x8f16 a[a_c+32:a_c+47], v[v_a+6:v_a+7], v[v_b+4:v_b+5], a[a_c+32:a_c+47]     ; repeat:1x0, step:0x0, num_a_c:16

    v_mfma_f32_32x32x8f16 a[a_c+48:a_c+63], v[v_a+6:v_a+7], v[v_b+6:v_b+7], a[a_c+48:a_c+63]     ; repeat:1x1, step:0x0, num_a_c:16

L_igemm_fwd_gtcx_nhwc_fp16_bx0_ex0_bt64x256x32_wt32x32x8_ws1x1_wr2x2_ta1x8x1x1_1x4x1x64_tb1x8x4x1_1x4x1x64_vs1_gkgs_mfma_end:
    s_waitcnt lgkmcnt(0)
    s_barrier
    ds_read_b64 v[v_a:v_a+1], v[v_sld_a_os]
    ds_read_b64 v[v_b:v_b+1], v[v_sld_b_os]
    ds_read_b64 v[v_b+2:v_b+2+1], v[v_sld_b_os] offset:2048
    ds_read_b64 v[v_a+2:v_a+2+1], v[v_sld_a_os] offset:512
    ; k iteration : 0
    s_waitcnt lgkmcnt(2)
    v_mfma_f32_32x32x8f16 a[a_c+0:a_


.m3.1.1.2.cmml" xref="A1.Thmtheorem5.p1.5.m3.1.1.2"></lt><apply id="A1.Thmtheorem5.p1.5.m3.1.1.1.cmml" xref="A1.Thmtheorem5.p1.5.m3.1.1.1"><times id="A1.Thmtheorem5.p1.5.m3.1.1.1.2.cmml" xref="A1.Thmtheorem5.p1.5.m3.1.1.1.2"></times><ci id="A1.Thmtheorem5.p1.5.m3.1.1.1.3.cmml" xref="A1.Thmtheorem5.p1.5.m3.1.1.1.3">𝑚</ci><apply id="A1.Thmtheorem5.p1.5.m3.1.1.1.1.1.1.cmml" xref="A1.Thmtheorem5.p1.5.m3.1.1.1.1.1"><csymbol cd="ambiguous" id="A1.Thmtheorem5.p1.5.m3.1.1.1.1.1.1.1.cmml" xref="A1.Thmtheorem5.p1.5.m3.1.1.1.1.1">subscript</csymbol><ci id="A1.Thmtheorem5.p1.5.m3.1.1.1.1.1.1.2.cmml" xref="A1.Thmtheorem5.p1.5.m3.1.1.1.1.1.1.2">𝑆</ci><ci id="A1.Thmtheorem5.p1.5.m3.1.1.1.1.1.1.3.cmml" xref="A1.Thmtheorem5.p1.5.m3.1.1.1.1.1.1.3">𝑖</ci></apply></apply><infinity id="A1.Thmtheorem5.p1.5.m3.1.1.3.cmml" xref="A1.Thmtheorem5.p1.5.m3.1.1.3"></infinity></apply></annotation-xml><annotation encoding="application/x-tex" id="A1.Thmtheorem5.p1.5.m3.1c">m(S_{i})<\infty</annotation><annotation encoding="application/x-llamapun" id="A1.Thmtheorem5.p1.5.m3.1d">italic_m ( italic_S start_POSTSUBSCRIPT italic_i end_POSTSUBSCRIPT ) < ∞</annotation></semantics></math>, <math alttext="a_{i}\in\mathbb{R}" class="ltx_Math" display="inline" id="A1.Thmtheorem5.p1.6.m4.1"><semantics id="A1.Thmtheorem5.p1.6.m4.1a"><mrow id="A1.Thmtheorem5.p1.6.m4.1.1" xref="A1.Thmtheorem5.p1.6.m4.1.1.cmml"><msub id="A1.Thmtheorem5.p1.6.m4.1.1.2" xref="A1.Thmtheorem5.p1.6.m4.1.1.2.cmml"><mi id="A1.Thmtheorem5.p1.6.m4.1.1.2.2" xref="A1.Thmtheorem5.p1.6.m4.1.1.2.2.cmml">a</mi><mi id="A1.Thmtheorem5.p1.6.m4.1.1.2.3" xref="A1.Thmtheorem5.p1.6.m4.1.1.2.3.cmml">i</mi></msub><mo id="A1.Thmtheorem5.p1.6.m4.1.1.1" xr