mask8];
    u ^= _sbox2_0222[(t1 >> 16) & _mask8];
    u ^= _sbox1_1110[(t1 >> 24) & _mask8];
    t2 = s[3] ^ skey[3 + keyoff];
    v = _sbox1_1110[t2 & _mask8];
    v ^= _sbox4_4404[(t2 >> 8) & _mask8];
    v ^= _sbox3_3033[(t2 >> 16) & _mask8];
    v ^= _sbox2_0222[(t2 >> 24) & _mask8];

    s[0] ^= u ^ v;
    s[1] ^= u ^ v ^ _rotateRight32(u, 8);
  }

  static void _camelliaFLs(List<int> s, List<int> fkey, int keyoff) {
    s[1] ^= _rotateLeft32(s[0] & fkey[keyoff], 1);
    s[0] ^= fkey[1 + keyoff] | s[1];

    s[2] ^= fkey[3 + keyoff] | s[3];
    s[3] ^= _rotateLeft32(fkey[2 + keyoff] & s[2], 1);
  }

  void _setKey(bool forEncryption, Uint8List key) {
    final k = List.filled(8, 0);
    final ka = List.filled(4, 0);
    final kb = List.filled(4, 0);
    final t = List.filled(4, 0);

    switch (key.length) {
      case 16:
        _keyIs128 = true;
        k[0] = _bytes2uint(key, 0);
        k[1] = _bytes2uint(key, 4);
        k[2] = _bytes2uint(key, 8);
        k[3] = _bytes2uint(key, 12);
        break;
      case 24:
        k[0] = _bytes2uint(key, 0);
        k[1] = _bytes2uint(key, 4);
        k[2] = _bytes2uint(key, 8);
        k[3] = _bytes2uint(key, 12);
        k[4] = _bytes2uint(key, 16);
        k[5] = _bytes2uint(key, 20);
        k[6] = ~k[4];
        k[7] = ~k[5];
        _keyIs128 = false;
        break;
      case 32:
        k[0] = _bytes2uint(key, 0);
        k[1] = _bytes2uint(key, 4);
        k[2] = _bytes2uint(key, 8);
        k[3] = _bytes2uint(key, 12);
        k[4] = _bytes2uint(key, 16);
        k[5] = _bytes2uint(key, 20);
        k[6] = _bytes2uint(key, 24);
        k[7] = _bytes2uint(key, 28);
        _keyIs128 = false;
        break;
      default:
        throw Exception('Key size are only 16/24/32 bytes.');
    }

    for (var i = 0; i < 4; i++) {
      ka[i] = k[i] ^ k[i + 4];
    }
    /* compute KA */
    _camelliaF2(ka, _sigma, 0);
    for (var i = 0; i < 4; i++) {
      ka[i] ^= k[i];
    }
    _camelliaF2(ka, _sigma, 4);

    if (_keyIs128) {
      if (forEncryption) {
        /* KL dependant keys */
        _kw[0] = k[0];
        _kw[1] = k[1];
        _kw[2] = k[2];
        _kw[3] = k[3];
        _roldq(15, k, 0, _sub


/* SPDX-License-Identifier: GPL-2.0-only */
/*
 * Copyright (C) 2012 Regents of the University of California
 * Copyright (C) 2017 SiFive
 * Copyright (C) 2020 Vitaly Wool, Konsulko AB
 */

#include <asm/pgtable.h>
#define LOAD_OFFSET KERNEL_LINK_ADDR
/* No __ro_after_init data in the .rodata section - which will always be ro */
#define RO_AFTER_INIT_DATA

#include <asm/vmlinux.lds.h>
#include <asm/page.h>
#include <asm/cache.h>
#include <asm/thread_info.h>
#include <asm/set_memory.h>

OUTPUT_ARCH(riscv)
ENTRY(_start)

jiffies = jiffies_64;

SECTIONS
{
	/* Beginning of code and text segment */
	. = LOAD_OFFSET;
	_xiprom = .;
	_start = .;
	HEAD_TEXT_SECTION
	INIT_TEXT_SECTION(PAGE_SIZE)
	/* we have to discard exit text and such at runtime, not link time */
	__exittext_begin = .;
	.exit.text :
	{
		EXIT_TEXT
	}
	__exittext_end = .;

	.text : {
		_text = .;
		_stext = .;
		TEXT_TEXT
		SCHED_TEXT
		LOCK_TEXT
		KPROBES_TEXT
		ENTRY_TEXT
		IRQENTRY_TEXT
		SOFTIRQENTRY_TEXT
		_etext = .;
	}
	RO_DATA(L1_CACHE_BYTES)
	.srodata : {
		*(.srodata*)
	}
	.init.rodata : {
		INIT_SETUP(16)
		INIT_CALLS
		CON_INITCALL
		INIT_RAM_FS
	}
	_exiprom = .;			/* End of XIP ROM area */

/*
 * From this point, stuff is considered writable and will be copied to RAM
 */
	__data_loc = ALIGN(PAGE_SIZE);		/* location in file */
	. = ALIGN(SECTION_ALIGN);		/* location in memory */

#undef LOAD_OFFSET
#define LOAD_OFFSET (KERNEL_L


U의 불필요한 공간 낭비 문제를 해결한 알고리즘
- 구현 방법
    - 최근 사용 여부를 확인하기 위해 각 페이지마다 두 개의 비트(참조 비트, 변형 비트)를 사용하여 미래를 추정함
        - 참조 비트: 초기값이 0이며, 페이지에 접근(read/execute)하면 1이 됨
        - 변형 비트: 초기값이 0이며, 페이지가 변경(write/append)하면 1이 됨
    - 각 페이지의 상태
        - Class 0 - `(0, 0)`: 모든 페이지의 초기 상태
        - Class 1 -`(0, 1)`: 페이지에 쓰기 또는 추가와 같은 변경이 일어난 경우
        - Class 2 -`(1, 0)`: 페이지에 읽기 또는 실행과 같은 접근이 발생한 경우
        - Class 3 -`(1, 1)`: 접근과 변경 두 가지 연산이 모두 발생한 경우
    - NUR에서는 대상 페이지를 선정할 때 페이지를 위와 같이 4가지의 클래스로 나누고, 가장 낮은 클래스의 랜덤한 페이지를 선택함
        - 우선 고려 대상은 참조 비트임
    - 모든 페이지의 비트가 `(1, 1)`일 경우에는 어떤 페이지가 더 자주 사용되는지 알 수 없어 교체 알고리즘을 정상적으로 사용할 수 없음
        - 따라서 NRU에서 모든 페이지가 `(1, 1)`이 되면 모든 페이지 비트를 `(0, 0)`으로 초기화 함(reset)
- 특징
    - LRU와 LFU와 성능이 비슷하며, FIFO보다 성능이 우수함
    - NUR은 2bit만 추가하여 다른 알고리즘과 유사한 성능을 낼 수 있음
    - 쉽게 구현할 수 있음
- 단점
    - 각 페이지의 참조를 유지 및 업데이트하고 비트를 수정하기 위해서는 추가적인 하드웨어 지원이나 소프트웨어 오버헤드가 필요함
        - 이 때문에 실제로 LRU 알고리즘을 더 많이 사용�


rType=type,
                                               ownerId=id)
    else:
        return admin_client.list_resource_pool(ownerType=type,
                                               ownerId=id,
                                               qualifier=qualifier)

def wait_setting_active(api_client, setting, timeout=45):
    start = time.time()
    setting = api_client.by_id_setting(setting.name)
    while setting.value != setting.activeValue:
        time.sleep(.5)
        setting = api_client.by_id('setting', setting.id)
        if time.time() - start > timeout:
            msg = 'Timeout waiting for [{0}] to be done'.format(setting)
            raise Exception(msg)

    return setting

def api_client(access_key, secret_key, project_id=None):
    return cattle.from_env(url=cattle_url(project_id),
                           cache=False,
                           access_key=access_key,
                           secret_key=secret_key)


                if (showSystemUI) AudioManager.FLAG_SHOW_UI else 0
            )
        } else {
            val target = getVolume(streamType) + step
            setVolume(target, showSystemUI, streamType)
        }
    }

    fun lowerVolume(step: Double?, showSystemUI: Boolean, streamType: Int) {
        if (step == null) {
            audioManager.adjustStreamVolume(
                streamType,
                AudioManager.ADJUST_LOWER,
                if (showSystemUI) AudioManager.FLAG_SHOW_UI else 0
            )
        } else {
            val target = getVolume(streamType) - step
            setVolume(target, showSystemUI, streamType)
        }
    }

    fun getMute(streamType: Int): Boolean {
        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            audioManager.isStreamMute(streamType)
        } else {
            audioManager.getStreamVolume(streamType) == 0
        }
    }

    private fun setMute(isMuted: Boolean, showSystemUI: Boolean, streamType: Int) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            audioManager.adjustStreamVolume(
                streamType,
                if (isMuted) AudioManager.ADJUST_MUTE else AudioManager.ADJUST_UNMUTE,
                if (showSystemUI) AudioManager.FLAG_SHOW_UI else 0
            )
        } else {
            audioManager.setStreamMute(streamType, isMuted)
        }
    }

    fun toggleMute(showSystemUI: Boolean, streamType: Int) {
        val isMuted = getMute(streamType)
        setMute(!isMuted, showSystemUI, streamType)
    }
}

import kotlin.math.*

data class Example(
    val [3;38;2;253;151;31mname: [3;38;2;102;217;239mString,
    val [3;38;2;253;151;31mnumbers[


});

    it("should add only the properties in the `replacer` array if it is given.", () => {
      Chai.expect(stringify(testObject, ["name", "surname"])).to.be.equals("{\"name\":\"Roger\",\"surname\":\"Garcia & <Garcia>\"}");
    });

    it("should transform the properties values with the `replacer` function if it is given.", () => {
      const replacer = (key, value) => {
        if (key && key !== "name") {
          return undefined;
        } else if (key === "name") {
          return "test";
        } else {
          return value;
        }
      };
      Chai.expect(stringify(testObject, replacer)).to.be.equals("{\"name\":\"test\"}");
    });

    it("should add the string given as `espacio` in each identation if it is given.", () => {
      Chai.expect(stringify(testObject, null, "    ")).to.be.equals("{"
      + "\n    \"name\": \"Roger\","
      + "\n    \"surname\": \"Garcia & <Garcia>\","
      + "\n    \"wight\": 72.6"
      + "\n}");
    });

    it("should add the amount of white spaces indicated by `espacio` in each identation if it is given.", () => {
      Chai.expect(stringify(testObject, null, 2)).to.be.equals("{"
      + "\n  \"name\": \"Roger\","
      + "\n  \"surname\": \"Garcia & <Garcia>\","
      + "\n  \"wight\": 72.6"
      + "\n}");
    });

    it("should escape <, >, and & characters if escape is true.", () => {
      Chai.expect(stringify(testObject, null, null, true)).to.be.equals("{\"name\":\"Roger\",\"surname\":\"Garcia \\u0026 \\u003cGarcia\\u003e\",\"wight\":72.6}");
    });
  });

  describe("#getCookiesFromHeader", () => {
    it("returns an empty object if the `Cookie` header is undefined.", () => {
      Chai.expect(getCookiesFromHeader(undefined, "SECRET")).to.be.empty;
    });

    it("returns an array with each cookie in the `Cookie` header.", () => {
      const cookies: { [name: string]: ICookie } = getCookiesFromHeader("cookie1=value1; cookie2=value2", "SECRET");

      Chai.expect(cookies.cookie1.name).to.be.equal("cookie1");
      Chai.expect(cookies.cookie1.value).to.be.equal("value1");
      Chai.expect(cookies.cookie2.name).to.be.equal("cookie2");
      Chai.expect(cookies.cookie2.value).to.be.equal("value2");
    });

    it("unsigns the value of the signed cookies.", () => {
      const signedValue = "s:" + sign("value", "SECRET");

      const cookies: { [name: string]: ICookie } = getCookiesFromHeader("cookie=" + signedValue, "SECRET");

      Chai.expect(cookies.cookie.value).to.be.equal("value");
    });

    it("parses the value of JSON cookies.", () => {
      const value = {ke1: "value1"};
      const parsedValue = "j:" + JSON.stringify(value);

      const cookies: { [name: string]: ICookie } = getCookiesFromHeader("cookie=" + parsedValue, "SECRET");

      Chai.expect(cookies.cookie.value).to.be.deep.equal(value);
    });

    it("unsigns and then parses the value of signed JSON cookies.", () => {
      const value = {ke1: "value1"};
      const parsedValue = "j:" + JSON.stringify(value);
      const signedValue = "s:" + sign(parsedValue, "SECRET");

      const cookies: { [name: string]: ICookie } = getCookiesFromHeader("cookie=" + signedValue, "SECRET");

      Chai.expect(cookies.cookie.value).to.be.deep.equal(value);
    });
  });


}

  .rightbar {
    opacity: 0;
    display: block;
    grid-area: rightbar;
    overflow: hidden;

    /* NOTE: This maintains the shadow bleed despite the overflow hidden prop. */
    margin: -15px;
    padding: 15px;
  }

  .navigation__container[data-leftbar-shown="false"] .leftbar {
    opacity: 0;
    pointer-events: none;
    /* NOTE: Doesn't work properly on initial page load, causes the sidebar to
    flicker visible and play the animation, need a way to not do this soon. */
    /* animation: fadeOutLeft 0.2s ease-in-out; */
  }

  .navigation__container[data-leftbar-shown="true"] .leftbar {
    opacity: 1;
    pointer-events: all;

    animation: fadeInLeft 0.2s ease-in-out;
  }

  .navigation__container[data-leftbar-shown="false"] .rightbar {
    opacity: 0;
    pointer-events: none;
  }

  .navigation__container[data-leftbar-shown="true"] .rightbar {
    opacity: 1;
    pointer-events: all;

    animation: fadeInRight 0.2s ease-in-out;
  }

  @keyframes fadeInLeft {
    from {
      opacity: 0;
      transform: translateX(-10px);
    }
    to {
      opacity: 1;
      transform: translateX(0px);
    }
  }
  @keyframes fadeOutLeft {
    from {
      opacity: 1;
      transform: translateX(0px);
    }
    to {
      opacity: 0;
      transform: translateX(-10px);
    }
  }

  @keyframes fadeInRight {
    from {
      opacity: 0;
      transform: translateX(10px);
    }
    to {
      opacity: 1;
      transform: translateX(0px);
    }
  }
  @keyframes fadeOutRight {
    from {
      opacity: 1;
      transform: translateX(0px);
    }
    to {
      opacity: 0;
      transform: translateX(10px);
    }
  }

  .navpill {
    display: none;
  }
}

@media screen and (min-width: 1280px) {
  .navgrid {
    grid-template-columns:
      var(--grid-col-padding-outer)
      18rem
      minmax(var(--grid-col-padding-inner), 1fr)
      minmax(0, var(--sizes-breakpoint-lg))
      minmax(var(--grid-col-padding-inner-right), 1fr)
      18rem
      var(--grid-col-padding-outer);

    grid-template-areas:
      " padtl    padtop    padtop   padtop   padtop   padtop    padtr    "
      " padleft  topbar    topbar   topbar   topbar   topbar    padright "
      " padleft  padmid    padmid   padmid   padmid   padmid    padright "
      " padleft  leftbar   .        main     .        rightbar  padright "
      " padbl    padbot    padbot   padbot   padbot   padbot    padbr    ";
  }
}

@media screen and (min-width: 768px) and (max-width: 1280px) {
  .navigation__container[data-leftbar-shown="false"] .main {
    grid-column: leftbar / main;
  }

  /* Hide the context pane when the screen is at "tablet" size *


id: "126:5",
		jp: "ダークオークのハーフブロック",
		en: "Dark Oak Wood Slab",
		jeid: "minecraft:dark_oak_slab",
		beid: "wooden_slab 5",
		x: "3",
		y: "14",
		tex: "Slab"
	}, {

		id: "44",
		jp: "石のハーフブロック",
		en: "Stone Slab",
		jeid: "minecraft:stone_slab",
		beid: "stone_slab4 2",
		x: "4",
		y: "14",
		tex: "Slab"
	}, {

		id: "44:8",
		jp: "滑らかな石のハーフブロック",
		en: "Smooth Stone Slab",
		jeid: "minecraft:smooth_stone_slab",
		beid: "stone_slab",
		x: "5",
		y: "14",
		tex: "Slab"
	}, {

		id: "44:1",
		jp: "砂岩のハーフブロック",
		en: "Sandstone Slab",
		jeid: "minecraft:sandstone_slab",
		beid: "stone_slab 1",
		x: "6",
		y: "14",
		tex: "Slab"
	}, {

		id: "44:9",
		jp: "研かれた砂岩のハーフブロック",
		en: "Cut Sandstone Slab",
		jeid: "minecraft:cut_sandstone_slab",
		beid: "stone_slab4 3",
		x: "7",
		y: "14",
		tex: "Slab"
	}, {

		id: "44:2",
		jp: "石化したオークのハーフブロック",
		en: "Petrified Oak Slab",
		jeid: "minecraft:petrified_oak_slab",
		beid: "stone_slab 2",
		x: "8",
		y: "14",
		tex: "Slab"
	}, {

		id: "44:3",
		jp: "丸石のハーフブロック",
		en: "Cobblestone Slab",
		jeid: "minecraft:cobblestone_slab",
		beid: "stone_slab 3",
		x: "9",
		y: "14",
		tex: "Slab"
	}, {

		id: "44:4",
		jp: "レンガのハーフブロック",
		en: "Bricks Slab",
		jeid: "minecraft:brick_slab",
		beid: "stone_slab 4",
		x: "1",
		y: "15",
		tex: "Slab"
	}, {

		id: "44:5",
		jp: "石レンガのハーフブロック",
		en: "Stone Bricks Slab",
		jeid: "minecraft:stone_brick_slab",
		beid: "stone_slab 5",
		x: "2",
		y: "15",
		tex: "Slab"
	}, {

		id: "44:6",
		jp: "ネザーレンガのハーフブロック",
		en: "Nether Bricks Slab",
		jeid: "minecraft:nether_brick_slab",
		beid: "stone_slab 7",
		x: "3",
		y: "15",
		tex: "Slab"
	}, {

		id: "44:7",
		jp: "クォーツのハーフブロック",
		en: "Quartz Block Slab",
		jeid: "minecraft:quartz_slab",
		beid: "stone_slab 6",


results, // TODO: fix unused results
    variant_size_differences,

    warnings, // treat all wanings as errors

    clippy::all,
    clippy::restriction,
    clippy::pedantic,
    clippy::nursery,
    // clippy::cargo
)]
#![allow(
    // Some explicitly allowed Clippy lints, must have clear reason to allow
    clippy::blanket_clippy_restriction_lints, // allow clippy::restriction
    clippy::implicit_return, // actually omitting the return keyword is idiomatic Rust code
    clippy::module_name_repetitions, // repeation of module name in a struct name is not big deal
    clippy::multiple_crate_versions, // multi-version dependency crates is not able to fix
    clippy::panic, // allow debug_assert, panic in production code
    // clippy::panic_in_result_fn,
    clippy::missing_errors_doc, // TODO: add error docs
    clippy::exhaustive_structs,
    clippy::exhaustive_enums,
    clippy::missing_panics_doc, // TODO: add panic docs
    clippy::panic_in_result_fn,
    clippy::print_stdout,
    clippy::use_debug
)]
// #![deny(missing_docs)]

//! Hello world example for Rust.
use wave_insight_lib::structure::Structure;
fn main() {
    let mut constructor = Structure::new_constructor();
    constructor.set_filename("input.vcd");
    constructor.set_version("Generated by VerilatedVcd");
    constructor.set_date("Mon Mar  7 16:03:36 2022");
    constructor.set_timescale("1ps");
    // find new submodule: TOP
    constructor.new_module("TOP");
    // find new wire: clk
    {
        let wire_id = "'";
        let wire_name = "clk";
        let wire_size = 1;
        let wire_refs = [0, 0];
        constructor.new_wire(wire_id, wire_name, wire_size, wire_refs);
    }
    // find new wire: io_state
    {
        let wire_id = "&";
        let wire_name = "io_state";
        let wire_size = 8;
        let wire_refs = [7, 0];
        constructor.new_wire(wire_id, wire_name, wire_size, wire_refs);
    }
    // find new wire: reset
    {
        let wire_id = "(";
        let wire_name = "reset";
        let wire_size = 1;
        let wire_refs = [0, 0];
        constructor.new_wire(wire_id, wire_name, wire_size, wire_refs);
    }
    // find new submodule: MyTopLevel
    constructor.new_module("MyTopLevel");
    // find new wire: clk
    {
        let wire_id = "'";
        let wire_name = "clk";
        let wire_size = 1;
        let wire_refs = [0, 0];
        constructor.new_wire(wire_id, wire_name, wire_size, wire_refs);
    }
    // find new wire: counter
    {
        let wire_id = ")";
        let wire_name = "counter";
        let wire_size = 8;
        let wire_refs = [7, 0];
        constructor.new_wire(wire_id, wire_name, wire_size, wire_refs);
    }
    // find End_Module
    constructor.end_module();
    // find new submodule: MyTest
    constructor.new_module("MyTest");
    // find new wire: clk
    {
        let wire_id = "'";
        let wire_name = "clk";
        let wire_size = 1;
        let wire_refs = [0, 0];
        constructor.new_wire(wire_id, wire_name, wire_size, wire_refs);
    }
    // find End_Module
    constructor.end_module();
    // find End_Module
    constructor.end_module();

    let s = constructor.structure;
    // println!();


schema.replica_host_status is not available.")
				return nil
			}
		}
		return err
	}
	defer replicaHostRows.Close()

	var (
		serverId       string
		role           string
		cpu            float64
		replicaLatency uint64
		replicaLag     float64
		logStreamSpeed float64
		replayLatency  uint64
	)
	for replicaHostRows.Next() {
		if err := replicaHostRows.Scan(
			&serverId,
			&role,
			&cpu,
			&replicaLatency,
			&replicaLag,
			&logStreamSpeed,
			&replayLatency,
		); err != nil {
			return err
		}
		ch <- prometheus.MustNewConstMetric(
			infoSchemaReplicaHostCpuDesc, prometheus.GaugeValue, cpu,
			serverId, role,
		)
		ch <- prometheus.MustNewConstMetric(
			infoSchemaReplicaHostReplicaLatencyDesc, prometheus.GaugeValue, float64(replicaLatency)*0.000001,
			serverId, role,
		)
		ch <- prometheus.MustNewConstMetric(
			infoSchemaReplicaHostLagDesc, prometheus.GaugeValue, replicaLag*0.001,
			serverId, role,
		)
		ch <- prometheus.MustNewConstMetric(
			infoSchemaReplicaHostLogStreamSpeedDesc, prometheus.GaugeValue, logStreamSpeed,
			serverId, role,
		)
		ch <- prometheus.MustNewConstMetric(
			infoSchemaReplicaHostReplayLatencyDesc, prometheus.GaugeValue, float64(replayLatency)*0.000001,
			serverId, role,
		)
	}
	return nil
}

// check interface
var _ Scraper = ScrapeReplicaHost{}
// Copyright 2018 The Prometheus Authors
// 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.

// Scrape `information_schema.innodb_metrics`.

package collector

import (
	"context"
	"database/sql"
	"errors"
	"fmt"
	"regexp"

	"github.com/cprobe/cprobe/lib/logger"
	"github.com/prometheus/client_golang/prometheus"
)

const infoSchemaInnodbMetricsEnabledColumnQuery = `
	SELECT
	    column_name
	  FROM information_schema.columns
	  WHERE table_schema = 'information_schema'
	    AND table_name = 'INNODB_METRICS'
	    AND column_name IN ('status', 'enabled')
	  LIMIT 1
	`

const infoSchemaInnodbMetricsQuery = `
		SELECT
		  name, subsystem, type, comment,
		  count
		  FROM information_schema.innodb_metrics
		  WHERE ` + "`%s` = '%s'"

// Metrics descriptors.
var (
	infoSchemaBufferPageReadTotalDesc = prometheus.NewDesc(
		prometheus.BuildFQName(namespace, informationSchema, "innodb_metrics_buffer_page_read_total"),
		"Total number of buffer pages read total.",
		[]string{"type"}, nil,
	)
	infoSchemaBufferPageWrittenTotalDesc = prometheus.NewDesc(
		prometheus.BuildFQName(namespace, informationSchema, "innodb_metrics_buffer_page_written_total"),
		"Total number of buffer pages written total.",
		[]string{"type"}, nil,
	)
	infoSchemaBufferPoolPagesDesc = prometheus.NewDesc(
		prometheus.BuildFQName(namespace, informationSchema, "innodb_metrics_buffer_pool_pages"),
		"Total number of buffer pool pages by state.",
		[]stri


_COND_EN bit.
  bld     r2, BOOT_CFG1_IO_COND_EN_OFFSET
  brcc    start_program                     // ISP_IO_COND_EN is 0: start the application.

  // Check CRC8 validity of the user page configuration word2.
  mov.w   r10, BOOT_CFG2_ADDRESS
  ld.w    r2, r10[0]                        // r2 = config_word2
  mov.w   r3, BOOT_CFG2_CRC8_POLYNOMIAL      // r3 = crc8_polynomial
  mov     r4, r2                            // r4 = config_word2_tempo
  rcall   test_crc8_end
  brne    start_loader  // The config word2 CRC8 is invalid: launch the ISP process.

  // Check the magic key of the user page configuration word2
  bfextu  r3, r2, BOOT_CFG2_BOOT_KEY_OFFSET, BOOT_CFG2_BOOT_KEY_SIZE
  cp.w    r3, BOOT_CFG2_BOOT_KEY_VALUE
  brne    start_loader  // The config word2 magic key is incorrect: launch the ISP process

  // ISP IO Condition active?
  bfextu  r3, r2, BOOT_CFG2_IO_COND_PIN_OFFSET, BOOT_CFG2_IO_COND_PIN_SIZE  // r3 = IO_COND_PIN
  cp.w    r3, AVR32_GPIO_NUMBER_OF_PINS
  brhs    start_loader  // The IO pin is invalid: launch the ISP process

  // Check the IO condition
  mov.w   r10, AVR32_GPIO_ADDRESS
  lsr     r4, r3, 5                         // r4 = IO_COND_PIN/32 = GPIO_port_IO_COND_PIN
#if UC3A || UC3B || UC3A3
  // The size of a gpio port section is 0x100
  lsl     r4, 8                             // r4 = offset to the port of the IO_COND_PIN
#elif UC3C || UC3L || UC3D
  // The size of a gpio port is 0x200
  lsl     r4, 9                             // r4 = offset to the port of the IO_COND_PIN
#endif
  add     r10, r4                           // r10 = &(AVR32_GPIO[port of the IO_COND_PIN].GPER)
  ld.w    r4, r10[AVR32_GPIO_PVR]           // r4 = AVR32_GPIO[port of the IO_COND_PIN].PVR
  andl    r3, 0x1F                          // r3 = pin&0x1F
  lsr     r4, r4, r3                        // r4 = gpio_port->pvr >> (pin & 0x1F)
  bfextu  r3, r2, BOOT_CFG2_IO_COND_LEVEL_OFFSET, BOOT_CFG2_IO_COND_LEVEL_SIZE  // r3 = IO_COND_LEVEL
  eor     r4, r3
  bld     r4, 0
  brcc    start_loader  // The ISP IO Condition is not active: launch the ISP process

start_program:
  cp.w    r0, r1
  brne    start_program_no_boot_key
  rcall   disable_wdt
  .global boot_program
  .type boot_program, @function
boot_program:
  // Clear ISP RAM Key
  mov.w   r8, BOOT_KEY_ADDRESS
  mov.w   r0, 0
  st.w    r8[0], r0
start_program_no_boot_key:
  mov.w   r0, AVR32_SR_GM_MASK | AVR32_SR_EM_MASK | (AVR32_SR_M_SUP << AVR32_SR_M_OFFSET)
  mtsr    AVR32_SR, r0
  .irp    rd, r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, sp, lr
    mov.w   \


N → infer user's move

Payoff: No keyboard input; the system sees and reacts like a real robot.

🦾 3. Execute moves via robot arm
Goal: Robot physically moves its piece after the engine replies.

🎯 Map chess squares (like "e2") to real-world XYZ positions

🛠 Use LeRobot or your robot's pick/place commands

💥 Demo: watch the machine “play a move” after trash-talking

Payoff: Fully embodied robot = max hackathon points.

🧠 4. Build a LangGraph agent (multitool brain)
Goal: Plug in an LLM to:

🧠 Explain why it made a move

🗯 Trash-talk based on context (e.g. “you blundered your queen”)

📜 Summarize game themes or openings

Payoff: Makes your bot feel like an actual coach — not just an engine wrapper.

🔄 5. Add a vision override / correction UI
Goal: Let user fix misread positions with a web/CLI fallback.

Optional GUI to select pieces manually if vision fails

Useful for debugging and when AprilTags fall off

Payoff: Makes the system robust enough for live demo conditions

⛓ Feature Dependency Map
css
Copy
Edit
[Current: Manual loop + Stockfish]
          │
          ▼
[ElevenLabs voice]  ◄──▶  [LangGraph agent]
          │
          ▼
  [Vision (camera-to-FEN)]
          │
          ▼
     [Robot arm controller]
🛠 What I recommend next
Step 1: Integrate ElevenLabs (TTS) into your current basic_loop.py.
I'll give you ~15 lines of code to add speech if you're ready.

Then: You’ll have a loop that plays, evaluates, and talks trash out loud.
From there we move on to camera input → robot output.

Let me know which one you want to tackle first.

You said:
yes please can you give me the elevenlabs code

ChatGPT said:
Perfect. Here's how to integrate ElevenLabs TTS into your existing loop in 3 quick steps.

🧱 Step 1: Install the SDK
bash
Copy
Edit
pip install elevenlabs
🔐 Step 2: Get your API key
Go to: https://www.elevenlabs.io/

Sign in → click your avatar → API Keys

Copy your key and set it in your environment:

bash
Copy
Edit
export ELEVENLABS_API_KEY="your-api-key-here"
Or store it in a .env file and load it using python-dotenv.

🧠 Step 3: Add TTS to your loop
In your Python script (basic_loop.py), add this snippet near the top:

python
Copy
Edit
from elevenlabs import generate, play, set_api_key
import os

# Setup ElevenLabs
set_api_key(os.getenv("ELEVENLABS_API_KEY"))

# Optional: choose a voice ID (you can find these at https://api.elevenlabs.io/v1/voices)
VOICE = "Rachel"  # or try "Adam", "Bella", etc.
Then replace the print(f"{smack}") line with:

python
Copy
Edit
print(f"🗯  {smack}")
audio = generate(text=smack, voice=VOICE, model="eleven_monolingual_v1")
play(audio)
✅ That’s it!
Now when Cagnus makes a move, you’ll hear it say the trash-talk line out loud.

Bonus: Speak the move too
You can add another line like:

python
Copy
Edit
spoken_move = f"I play {reply_move[0]}{reply_move[1]} to {reply_move[2]}{reply_move[3]}"
audio = generate(text=spoken_move, voice=VOICE, model="eleven_monolingual_v1")
play(audio)
Let me know when you're ready to move on to vision (camera → FEN), or want to tweak voice emotion/


x = True
if x:
    print(42)
else:
    print(0)


///
/// [SIMINOV FRAMEWORK - CORE]
/// Copyright [2014-2016] [Siminov Software Solution LLP|support@siminov.com]
///
/// 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.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Siminov.Core.Database.Design
{

    /// <summary>
    /// Exposes API's to provide condition on where clause to calculate group concat.
    /// </summary>
    public interface IGroupConcatClause
    {

        /// <summary>
        /// Used to specify EQUAL TO (=) condition.
        /// </summary>
        /// <param name="value">Value for which EQUAL TO (=) condition will be applied.</param>
        /// <returns>IGroupConcat Interface.</returns>
        IGroupConcat EqualTo(Object value);

        /// <summary>
        /// Used to specify NOT EQUAL TO (!=) condition.
        /// </summary>
        /// <param name="value">Value for which NOT EQUAL TO (=) condition will be applied.</param>
        /// <returns>IGroupConcat Interface.</returns>
        IGroupConcat NotEqualTo(Object value);

        /// <summary>
        /// Used to specify GREATER THAN (>) condition.
        /// </summary>
        /// <param name="value">Value for while GREATER THAN (>) condition will be specified.</param>
        /// <r


oat
import com.divpundir.mavlink.serialization.encodeInt16
import com.divpundir.mavlink.serialization.encodeString
import com.divpundir.mavlink.serialization.encodeUInt8
import com.divpundir.mavlink.serialization.safeDecodeFloat
import com.divpundir.mavlink.serialization.safeDecodeInt16
import com.divpundir.mavlink.serialization.safeDecodeString
import com.divpundir.mavlink.serialization.safeDecodeUInt8
import com.divpundir.mavlink.serialization.truncateZeros
import kotlin.Byte
import kotlin.ByteArray
import kotlin.Float
import kotlin.Int
import kotlin.Short
import kotlin.String
import kotlin.UByte
import kotlin.UInt
import kotlin.Unit

/**
 * Bind a RC channel to a parameter. The parameter should change according to the RC channel value.
 *
 * @param targetSystem System ID
 * @param targetComponent Component ID
 * @param paramId Onboard parameter id, terminated by NULL if the length is less than 16
 * human-readable chars and WITHOUT null termination (NULL) byte if the length is exactly 16 chars -
 * applications have to provide 16+1 bytes storage if the ID is stored as string
 * @param paramIndex Parameter index. Send -1 to use the param ID field as identifier (else the
 * param id will be ignored), send -2 to disable any existing map for this rc_channel_index.
 * @param parameterRcChannelIndex Index of parameter RC channel. Not equal to the RC channel id.
 * Typically corresponds to a potentiometer-knob on the RC.
 * @param paramValue0 Initial parameter value
 * @param scale Scale, maps the RC range [-1, 1] to a parameter value
 * @param paramValueMin Minimum param value. The protocol does not define if this overwrites an
 * onboard minimum value. (Depends on implementation)
 * @param paramValueMax Maximum param value. The protocol does not define if this overwrites an
 * onboard maximum value. (Depends on implementation)
 */
@GeneratedMavMessage(
  id = 50u,
  crcExtra = 78,
)
public data class ParamMapRc(
  /**
   * System ID
   */
  @GeneratedMavField(type = "uint8_t")
  public val targetSystem: UByte = 0u,
  /**
   * Component ID
   */
  @GeneratedMavField(type = "uint8_t")
  public val targetComponent: UByte = 0u,
  /**
   * Onboard parameter id, terminated by NULL if the length is less than 16 human-readable chars and
   * WITHOUT null termination (NULL) byte if the length is exactly 16 chars - applications have to
   * provide 16+1 bytes storage if the ID is stored as string
   */
  @GeneratedMavField(type = "char[16]")
  public val paramId: String = "",
  /**
   * Parameter index. Send -1 to use the param ID field as identifier (else the param id will be
   * ignored), send -2 to disable any existing map for this rc_channel_index.
   */
  @GeneratedMavField(type = "int16_t")
  public val paramIndex: Short = 0,
  /**
   * Index of parameter RC channel. Not equal to the RC channel id. Typically corresponds to a
   * potentiometer-knob on the RC.
   */
  @GeneratedMavField(type = "uint8_t")
  public val parameterRcChannelIndex: UByte = 0u,
  /**
   * Initial parameter value
   */
  @GeneratedMavField(type = "float")
  public val paramValue0: Float = 0F,
  /**
   * Scale, maps the RC range [-1, 1] to a parameter value
   */
  @GeneratedMavField(type = "float")
  public val scale: Float = 0F,
  /**
   * Minimum param value.


patches = [
    {
        "op": "replace",
        "path": "/ResourceTypes/AWS::Route53::HealthCheck/Properties/HealthCheckTags/Type",
        "value": "Tags",
    },
    {
        "op": "remove",
        "path": "/PropertyTypes/AWS::Route53::HealthCheck.HealthCheckTag",
    },
    {
        "op": "replace",
        "path": "/ResourceTypes/AWS::Route53::HostedZone/Properties/HostedZoneTags/Type",
        "value": "Tags",
    },
    {
        "op": "remove",
        "path": "/PropertyTypes/AWS::Route53::HostedZone.HostedZoneTag",
    },
    {
        "op": "move",
        "from": "/PropertyTypes/AWS::Route53::HostedZone.HostedZoneConfig",
        "path": "/PropertyTypes/AWS::Route53::HostedZone.HostedZoneConfiguration",
    },
    {
        "op": "replace",
        "path": "/ResourceTypes/AWS::Route53::HostedZone/Properties/HostedZoneConfig/Type",
        "value": "HostedZoneConfiguration",
    },
    {
        "op": "move",
        "from": "/PropertyTypes/AWS::Route53::HostedZone.VPC",
        "path": "/PropertyTypes/AWS::Route53::HostedZone.HostedZoneVPCs",
    },
    {
        "op": "replace",
        "path": "/ResourceTypes/AWS::Route53::HostedZone/Properties/VPCs/ItemType",
        "value": "HostedZoneVPCs",
    },
    {
        "op": "remove",
        "path": "/PropertyTypes/AWS::Route53::RecordSet.AliasTarget",
    },
    {
        "op": "remove",
        "path": "/PropertyTypes/AWS::Route53::RecordSetGroup.AliasTarget",
    },
    {
        "op": "add",
        "path": "/ResourceTypes/AWS::Route53::RecordSet/Properties/AliasTarget/PrimitiveType",
        "value": "AliasTarget",
    },
    {
        "op": "add",
        "path": "/PropertyTypes/AWS::Route53::RecordSetGroup.RecordSet/Properties/AliasTarget/PrimitiveType",
        "value": "AliasTarget",
    },
    {
        "op": "move",
        "from": "/ResourceTypes/AWS::Route53::RecordSet",
        "path": "/ResourceTypes/AWS::Route53::RecordSetType::RecordSet",
    },
]


r-Thin.woff2') format('woff2'),
       url('../fonts/Vazir-Thin.woff') format('woff'),
       url('../fonts/Vazir-Thin.ttf') format('truetype');
  font-weight: 100;
}

@font-face {
  font-family: Vazir;
  src: url('../fonts/Vazir-Light.eot');
  src: url('../fonts/Vazir-Light.eot?#iefix') format('embedded-opentype'),
       url('../fonts/Vazir-Light.woff2') format('woff2'),
       url('../fonts/Vazir-Light.woff') format('woff'),
       url('../fonts/Vazir-Light.ttf') format('truetype');
  font-weight: 300;
}

@font-face {
  font-family: Vazir;
  src: url('../fonts/Vazir-Medium.eot');
  src: url('../fonts/Vazir-Medium.eot?#iefix') format('embedded-opentype'),
       url('../fonts/Vazir-Medium.woff2') format('woff2'),
       url('../fonts/Vazir-Medium.woff') format('woff'),
       url('../fonts/Vazir-Medium.ttf') format('truetype');
  font-weight: 500;
}

@font-face {
  font-family: Vazir;
  src: url('../fonts/Vazir-Black.eot');
  src: url('../fonts/Vazir-Black.eot?#iefix') format('embedded-opentype'),
       url('../fonts/Vazir-Black.woff2') format('woff2'),
       url('../fonts/Vazir-Black.woff') format('woff'),
       url('../fonts/Vazir-Black.ttf') format('truetype');
  font-weight: 900;
}/**
 * This is the styling applied to an EventsSheet.
 * This also overwrite the default react-sortable-tree css.
 */

.gd-events-sheet .events-tree {
  font-family: var(--gdevelop-classic-font-family) !important;
  background: var(--event-sheet-event-tree-background-color);
}

/**
 * Ensure scroll is only on Y direction, preventing the display
 * of horizontal scrollbar.
 */
.gd-events-sheet .rst__virtualScrollOverride {
  overflow-x: hidden !important;
}

/**
 * Draggable handle on the left of an event
 */
.gd-events-sheet .move-handle {
  background: var(--event-sheet-rst-move-handle-background-color);
}

.gd-events-sheet .move-handle:hover {
  background-color: var(--event-sheet-rst-move-handle-hover-background-color);
}

.gd-events-sheet .ai-generated-event-move-handle {
  border-left: 1px solid;
  border-image: linear-gradient(
      to bottom,
      var(--event-sheet-rst-ai-generated-event-move-handle-gradient-color-1),
      var(--event-sheet-rst-ai-generated-event-move-handle-gradient-color-2),
      var(--event-sheet-rst-ai-generated-event-move-handle-gradient-color-3)
    )
    1;
}

/**
 * Scaffolding lines on the left
 */
.gd-events-sheet .rst__lineHalfHorizontalRight::before,
.gd-events-sheet .rst__lineFullVertical::after,
.gd-events-sheet .rst__lineHalfVerticalTop::after,
.gd-events-sheet .rst__lineHalfVerticalBottom::after {
  background-color: var(--event-sheet-rst-line-background-color);
}

/**
 * Background and default text color of content of an event
 */


ency stop procedures
- Monitor system health

---

## 🚨 Troubleshooting

### Common Issues

**1. Bot can't connect to C2 server**
```bash
# Check network connectivity
ping 192.168.1.100

# Check C2 server status
curl http://192.168.1.100:8080/health

# Check bot logs
docker logs bot-$(hostname)
```

**2. Container won't start**
```bash
# Check Docker status
docker ps -a

# Check container logs
docker logs container-name

# Restart container
docker restart container-name
```

**3. High resource usage**
```bash
# Check system resources
docker stats

# Limit container resources
docker run --memory=512m --cpus=0.5 image-name
```

**4. Network connectivity issues**
```bash
# Test connectivity between systems
telnet 192.168.1.100 8081

# Check firewall rules
sudo iptables -L

# Check port availability
sudo netstat -tuln | grep 8081
```

### Performance Optimization

**For C2 Server:**
```bash
# Increase container resources
docker run --memory=4g --cpus=2 ddos-lab/c2-server

# Optimize database
docker exec ddos-c2-server sqlite3 /app/data/ddos_lab.db "VACUUM;"
```

**For Bot Clients:**
```bash
# Limit bot resources to prevent system overload
docker run --memory=256m --cpus=0.5 ddos-lab/bot-client
```

---

## 📈 Scaling

### Adding More Bots
```bash
# Deploy additional bot on new system
./docker-scripts/deploy-bot.sh 192.168.1.100

# Verify connection in C2 dashboard
curl http://192.168.1.100:8080/api/bots
```

### Multiple Target Servers
```bash
# Deploy additional targets
./docker-scripts/deploy-target.sh

# Configure different ports
docker run -p 8080:80 nginx:alpine
docker run -p 8090:80 nginx:alpine
```

### Load Balancing
```bash
# Deploy multiple C2 servers with load balancer
docker run -d -p 80:80 nginx:alpine
# Configure nginx.conf for load balancing
```

---

## 🎓 Educational Benefits

### Learning Objectives
- **Distributed Systems**: Understanding coordination across multiple systems
- **Network Security**: Real-world attack simulation
- **Container Orchestration**: Docker deployment at scale
- **System Monitoring**: Resource usage and performance analysis
- **Incident Response**: Attack detection and mitigation

### Practical Skills
- Docker container deployment
- Network configuration and troubleshooting
- System administration across multiple machines
- Security monitoring and analysis
- Distributed application architecture

---

## 🧹 Cleanup

### Stop All Containers

**On C2 Server:**
```bash
docker stop ddos-c2-server
docker rm ddos-c2-server
```

**On Each Bot System:**
```bash
docker stop bot-$(hostname)
docker rm bot-$(hostname)
```

**On Target System:**
```bash
docker stop ddos-target-server
docker rm ddos-target-server
```

### Remove Images
```bash
# On all systems
docker rmi ddos-lab/c2-server
docker rmi ddos-lab/bot-client
docker rmi nginx:alpine

# Clean up unused resources
docker system prune -f
```

---

## 📊 Expected Performance

### Attack Capacity
- **28 bots × 100 req/sec = 2,800 requests/second**
- **Sustained attack duration**: Limited by target capacity
- **Network bandwidth**: ~50-100 Mbps total

### Resource Usage
- **C2 Server**: 2-4GB RAM


目
                        AppData.getStashes().forEach((stash, index) => {
                            const stashElement = createSafeListItem(
                                stash.name + ': ' + stash.message,
                                selectedStashIndex === index,
                                () => selectStash(index, stash.name)
                            );
                            dynamicList.appendChild(stashElement);
                        });
                    } else {
                        // Recent Commits mode - 使用安全的DOM操作
                        const commitsTitle = document.createElement('div');
                        commitsTitle.className = 'list-title';
                        commitsTitle.textContent = 'Recent Commits';
                        dynamicList.appendChild(commitsTitle);

                        const recentCommits = AppData.getRecentCommits();
                        recentCommits.forEach((commitHash, index) => {
                            const commitElement = createSafeListItem(
                                `${commitHash} fix(ui)`,
                                selectedCommitIndex === index,
                                () => selectCommitByIndex(index, commitHash),
                                '📝'
                            );
                            dynamicList.appendChild(commitElement);
                        });
                    }
                    break;

                // 其他视图保持使用原来的逻辑，但添加清理
                default:
                    // 继续使用原有逻辑但需要添加事件清理
                    updateDynamicListLegacy(view);
                    return;
            }
        }

        function updateDynamicListLegacy(view) {
            const dynamicList = document.getElementById('dynamicList');
            if (!dynamicList) return;

            // 清理旧的事件监听器
            EventManager.cleanupContainer(dynamicList);

            let content = '';

            switch(view) {
                case 'git-log':
                    const selectedBranchName = branchNames[selectedBranchIndex] || branchNames[0];

                    // 创建标题
                    const title = document.createElement('div');
                    title.className = 'list-title';
                    title.textContent = `Git Log - ${selectedBranchName}`;
                    dynamicList.appendChild(title);

                    // 创建当前分支信息
                    const branchInfo = document.createElement('div');
                    branchInfo.style.cssText = 'margin-bottom: 12px; padding: 8px; background: #2d2d30; border-radius: 4px;';
                    branchInfo.innerHTML = `

🔍 Viewing Branch:

${escapeHtml(selectedBranchName)}

                    `;
                    dynamicList.appendChild(branchInfo);

                    // 创建分支切换标题
                    const switchTitle = document.createElement('div');
                    switchTitle.className = 'list-title';
                    switchTitle.style.marginTop = '16px';
                    switchTitle.textContent = 'Switch Branch:';
                    dynamicList.appendChild(switchTitle);

                    // 添加分支列表
                    branchNames.forEach((branchName, index) => {
                        const branchElement = createBranchListElement(
                            index,
                            branchName,
                            selectedBranchIndex === index,
                            currentBranchIndex === index
                        );
                        dynamicList.appendChild(branchElement);
                    });
                    break;

                case 'branches':
                    // 创建分支列表标题
                    const branchesTitle = document.createElement('div');
                    branchesTitle.className = 'list-title';
                    branchesTitle.textContent = 'Branches List';
                    dynamicList.appendChild(branchesTitle);

                    // 添加分支列表
                    branchNames.forEach((branchName, index) => {
                        const branchElement = createBranchListElem


i += 8)
		;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
		cmp i, width
		jge .EndOf_LoopWidth8
		.LoopWidth8:
			vmovaps ymm0, [Aptr + (i + 0)*COMPV_YASM_FLOAT32_SZ_BYTES]
			vsubps ymm0, ymm4
			vmovaps [Rptr + (i + 0)*COMPV_YASM_FLOAT32_SZ_BYTES], ymm0
			add i, 8
			cmp i, width
			jl .LoopWidth8
		.EndOf_LoopWidth8:

		dec height
		lea Aptr, [Aptr + Astride]
		lea Rptr, [Rptr + Rstride]
		jnz .LoopHeight
	.EndOf_LoopHeight:

	%undef Aptr
	%undef subVal1
	%undef Rptr
	%undef width
	%undef height
	%undef Astride
	%undef Rstride

	%undef width32
	%undef i

	;; begin epilog ;;
	pop rbx
	pop rdi
	pop rsi
	COMPV_YASM_UNSHADOW_ARGS
	mov rsp, rbp
	pop rbp
	ret

%endif ; COMPV_YASM_ABI_IS_64BIT


lačování hlavního raketoplánu a získáme rychlý letmý pohled vnitřku spolu s několika zaparkovanými raketoplány.
Máte nějaké nápady, proč nebyl hlavní raketoplán nikdy vidět mimo tyto dva případy?
odhlásili jste se a přihlásili jste se do své aplikace?
dělal jsi 2 procedury?
pokud jste provedli oba postupy a problém nevyřešili, mohu vám vrátit peníze na váš účet Store Credit.
tak si knihu dle vlastního výběru můžete ihned koupit.
bylo by to v pořádku
jste tam?
pro účely kvality budu muset uvolnit tento chat jestliže není interakce v následujících 2 minutách
Děkuji za kontaktování #PRS_ORG#, bylo mi ctí vám dnes pomoct.
Doufám, že máte skvělý den.
Dobře, prosím, udělejte mi laskavost, abych pokračoval podle dalších kroků>
Zapojte nástěnnou nabíječku (není součástí dodávky) do elektrické zásuvky a poté připojte čtečku elektronických knih k nástěnné nabíječce.
Stiskněte a podržte tlačítko napájení, dokud se v horní části obrazovky nezobrazí nápis „Vypnuto“.
Pokračujte přidržením tlačítka napájení po dobu 3-4 sekund.
Uvolněte tlačítko elektrického napájení.
Stiskněte a podržte tlačítko elektrického napájení na čtečce elektronických knih po dobu 30 sekund.
Počkejte, až se objeví obrazovka „Obnovit“.
Uvolněte tlačítko elektrického napájení.
Po resetování e-čtečky budete požádáni o nastavení jazykových preferencí a WiFi sítě.
Poté se budete muset přihlásit pomocí své e-mailové adresy a hesla
Pokud to nefunguje, nyní se, prosím, odhlaste a přihlaste se zpět ze své čtečky elektronických knih
Odhlaste se z vašeho #PRS_ORG#
Přejděte na domovskou obrazovku.
Ikona Víc na spodku obrazovky.
Klikněte na Nastavení.
Klikněte na Účty.
Pod #PRS_ORG# klikněte na Odhlášení.
Zobrazí se obrazovka potvrzení.
I když neznáte své heslo, můžete si vytvořit nové heslo podle kroků, které jsem poslal.
Ale nebojte se, mohu vám také poslat odkaz na resetování vašeho hesla
Děkuji, že jste si dnes našli čas na rozhovor se mnou.
Jakmile tento chat skončí, bude vám zaslán e-mail se zpětnou vazbou „ohodnoťte můj chat“.
Pokud máte chvilku, vyplňte prosím toto, ale pokud nemáte čas, přeji vám krásný den a ještě jednou děku


":27,"28":28}],23:[function(_dereq_,module,exports){
/**
 * Copyright 2013-2015, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 *
 * @providesModule HTMLDOMPropertyConfig
 */

/*jslint bitwise: true*/

'use strict';

var DOMProperty = _dereq_(10);
var ExecutionEnvironment = _dereq_(21);

var MUST_USE_ATTRIBUTE = DOMProperty.injection.MUST_USE_ATTRIBUTE;
var MUST_USE_PROPERTY = DOMProperty.injection.MUST_USE_PROPERTY;
var HAS_BOOLEAN_VALUE = DOMProperty.injection.HAS_BOOLEAN_VALUE;
var HAS_SIDE_EFFECTS = DOMProperty.injection.HAS_SIDE_EFFECTS;
var HAS_NUMERIC_VALUE = DOMProperty.injection.HAS_NUMERIC_VALUE;
var HAS_POSITIVE_NUMERIC_VALUE =
  DOMProperty.injection.HAS_POSITIVE_NUMERIC_VALUE;
var HAS_OVERLOADED_BOOLEAN_VALUE =
  DOMProperty.injection.HAS_OVERLOADED_BOOLEAN_VALUE;

var hasSVG;
if (ExecutionEnvironment.canUseDOM) {
  var implementation = document.implementation;
  hasSVG = (
    implementation &&
    implementation.hasFeature &&
    implementation.hasFeature(
      'http://www.w3.org/TR/SVG11/feature#BasicStructure',
      '1.1'
    )
  );
}

var HTMLDOMPropertyConfig = {
  isCustomAttribute: RegExp.prototype.test.bind(
    /^(data|aria)-[a-z_][a-z\d_.\-]*$/
  ),
  Properties: {
    /**
     * Standard Properties
     */
    accept: null,
    acceptCharset: null,
    accessKey: null,
    action: null,
    allowFullScreen: MUST_USE_ATTRIBUTE | HAS_BOOLEAN_VALUE,
    allowTransparency: MUST_USE_ATTRIBUTE,
    alt: null,
    async: HAS_BOOLEAN_VALUE,
    autoComplete: null,
    // autoFocus is polyfilled/normalized by AutoFocusMixin
    // autoFocus: HAS_BOOLEAN_VALUE,
    autoPlay: HAS_BOOLEAN_VALUE,
    cellPadding: null,
    cellSpacing: null,
    charSet: MUST_USE_ATTRIBUTE,
    checked: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,
    classID: MUST_USE_ATTRIBUTE,
    // To set className on SVG elements, it's necessary to use .setAttribute;
    // this works on HTML elements too in all browsers except IE8. Conveniently,
    // IE8 doesn't support SVG and so we can simply use the attribute in
    // browsers that support SVG and the property in browsers that don't,
    // regardless of whether the element is HTML or SVG.
    className: hasSVG ? MUST_USE_ATTRIBUTE : MUST_USE_PROPERTY,
    cols: MUST_USE_ATTRIBUTE | HAS_POSITIVE_NUMERIC_VALUE,
    colSpan: null,
    content: null,
    contentEditable: null,
    contextMenu: MUST_USE_ATTRIBUTE,
    controls: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,
    coords: null,
    crossOrigin: null,
    data: null, // For `<object />` acts as `src`.
    dateTime: MUST_USE_ATTRIBUTE,
    defer: HAS_BOOLEAN_VALUE,
    dir: null,
    disabled: MUST_U


 HiTensionSocket
    ///         The resulting HiTensionSocket.
    #[staticmethod]
    #[text_signature = "(address)"]
    fn accept(address: &str) -> PyResult<Self> {
        let listener = TcpListener::bind(address)?;
        Ok(HiTensionSocket {
            stream: listener.accept()?.0,
        })
    }

    ///     Send text data to the remote. Data shall be ended with a newline
    ///     '\n'.
    ///
    ///     Parameters
    ///     ----------
    ///     data: bytearray
    ///         Text data to send.
    #[text_signature = "($self, data, /)"]
    fn send(&mut self, data: &[u8]) -> PyResult<()> {
        self.stream.write_all(data)?;
        Ok(())
    }

    ///     Read text data from the remote.
    ///
    ///     Returns
    ///     -------
    ///     out: bytearray
    ///         Text data received.
    #[text_signature = "($self, /)"]
    fn read(&mut self, py: Python) -> PyResult<Py<PyByteArray>> {
        let mut bufstream = BufReader::new(&mut self.stream);
        let mut data = vec![];
        let i = bufstream.read_until(4, &mut data)?;

        Ok(PyByteArray::new(py, &data[..i - 1]).into())
    }

    ///     Send a double precision numpy array as a high tension message to
    ///     the remote. Data may be send in multible packets.
    ///
    ///     Parameters
    ///     ----------
    ///     array: ndarray
    ///         Double precision numpy array to send.
    #[text_signature = "($self, array, /)"]
    fn hisend(&mut self, x: PyReadonlyArrayDyn<f64>) -> PyResult<()> {
        let slice = x.as_slice()?;
        hiwrite(&mut self.stream, slice)?;
        Ok(())
    }

    ///     Read a double precision numpy array as a high tension message from
    ///     the remote.
    ///
    ///     Returns
    ///     -------
    ///     out: ndarray
    ///         Double precision numpy array received.
    #[text_signature = "($self, /)"]
    fn hiread(&mut self, py: Python) -> PyResult<Py<PyArray1<f64>>> {
        let buf = hiread(&mut self.stream)?;
        let array = PyArray::from_vec(py, buf);
        Ok(array.to_owned())
    }

    ///     Signal the end of a high tension message to the remote.
    #[text_signature = "($self, /)"]
    fn hidelimiter(&mut self) -> PyResult<()> {
        hidelimiter(&mut self.stream)?;
        Ok(())
    }
}

#[pymodule]
pub fn hi_tension(_py: Python, m: &PyModule) -> PyResult<()> {
    m.add_class::<HiTensionSocket>()
}
use regex::Regex;
use run_script::ScriptOptions;
use std::io;

use crate::errors::{AppResult, Error};
use io::Write;

pub fn connected_ssid() -> AppResult<String> {
    let (_, output, _) = run_script::run_script!(
        r#"
            /System/Library/PrivateFrameworks/Apple80211.framework/Versions/Current/Resources/airport -I
        "#
    )
    .expect("Airport not found");

    let re = Regex::new(r#"\bSSID:\s?(.*)"#).unwrap();

    let ssid = re
        .captures(&output)
        .ok_or(Error::SsidMissing)?
        .get(1)
        .ok_or(Error::SsidMissing)?
        .as_str();

    if ssid.is_empty() {
        Err(Error::SsidMissing)
    } else {
        Ok(ssid.to_string())
    }
}

pub fn get


y();

  // Set email to something correct
  contact.setValue("7777-88888");
  errors = contact.errors || {};
  expect(errors['required']).toBeFalsy();
  expect(errors['pattern']).toBeFalsy();
});

it('submitting a form emits a employee', () => {

  expect(component.employeeForm.valid).toBeFalsy();

  component.employeeForm.controls['email'].setValue("test@test.com");
  component.employeeForm.controls['name'].setValue("Test Smith");
  component.employeeForm.controls['address'].setValue("257th Street Test");
  component.employeeForm.controls['contactNo'].setValue("7777-88888");

  expect(component.employeeForm.valid).toBeTruthy();

  component.saveEmployee(component);

  /*let employee: IEmployee;
  // Subscribe to the Observable and store the user in a local variable.
  component.saveEmployee.a((value) => employee = value);

  // Now we can check to make sure the emitted value is correct
  expect(employee.email).toBe("test@test.com");
  expect(employee.name).toBe("Test Da Silva");
  expect(employee.address).toBe("257th Street Test");
  expect(employee.contactNo).toBe("7777-88888");*/

});

});
export type ConfigType = {
    /**
     * Generic configurations to the app.
     */
    app: {
        /**
         * Specify the path where are store the custom controllers.
         */
        controllersPath: string,
        /**
         * Specify the path where are store the models.
         */
        modelsPath: string,
        /**
         * Set the port number listen by the http request.
         */
        port: number
    }
    /**
     * Configurations to the database.
     */
    database: ConfigDatabase,
    /**
     * Session configuration
     */
    session: ConfigSession,
    [key: string]: any
};

export type ConfigDatabase = {
    /**
     * Set the hostname or url to access to the database server.
     */
    host: string,
    /**
     * User to login to the database.
     */
    user?: string,
    /**
     * Password to login to the database.
     */
    pass?: string,
    /**
     * Name of the database to use.
     */
    name: string,
    /**
     * Port of the database to use, if you don't specify any it will use the
     * default `27017` port.
     */
    port?: number
}

export type ConfigSession = {
    /**
     * Time to live the session specify in seconds
     */
    ttl: number,
    /**
     * Phrase to sign the JWT sessions
     */
    jwtSecret: string
}

export class Config {
    private _config: ConfigType;
    private static readonly _configInstance = new Config();

    /**
     * Just can extist 1 object of config, this the reason because the only way
     * to access to the object is with this function
     */
    public static get instance(): Config {
        return this._configInstance;
    }

    /**
     * Method to access to the hashmap that conains the values saved.
     */
    public get values() {
        return this._config;
    }

    /**
     * The config class is defined as singleton, this the reason because the
     * constructor is a private and empty function.
     */
    private constructor() { }

    /**
     * Save the config values
     * @param config Hashmap that contains the config values.
     */
    public save(config: ConfigType): void {
        this._config = config;
    }
}
import {ErrorWithCode} from "../errors/error-with-code";
import {ERROR_CODES} from "../types/todo-list-types";

export class ErrorUtils {

    public static httpErrorHandler(error: ErrorWith


 res_selection = await run_task(
            prompt_f=prompt_f,
            records=to_select_records,
            n=n,
            temperature=temperature,
            backbone=backbone,
            seed=seed,
            disable_hinting=disable_hinting
        )
        # save_results
        save_res(outpath, res_selection)

        # record idxs selection performed on
        selection_idx_path = outdir / "selection_performed_idxs.txt"
        with open(selection_idx_path, "w") as f:
            f.write("\n".join(map(str, torun_idxs)))

        # copy input file for postprocessing
        copypath = outdir / f"{outpath.stem}_input.jsonl"
        with jsl.open(copypath, "w") as writer:
            writer.write_all(records)

        # make copy of rims prompt used
        copypath_p = outdir / Path(prompt_f).name
        copypath_p.open("w").write(open(prompt_f).read())

        # to-postprocess-with are as follows:
        print(outpath)
        print(selection_idx_path)
        print(copypath)

if __name__ == "__main__":
    fire.Fire(main)


      pauseOnExit: true,
    );
// Copyright (c) 2019, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

import 'package:test/test.dart';
import 'package:vm_service/vm_service.dart';

import 'common/test_helper.dart';

Future<void> sleep(int milliseconds) =>
    Future.delayed(Duration(milliseconds: milliseconds));

var tests = <IsolateTest>[
  (VmService service, IsolateRef isolate) async {
    final isolateId = isolate.id!;

    AllocationProfile result = await service.getAllocationProfile(isolateId);
    expect(result.dateLastAccumulatorReset, isNull);
    expect(result.dateLastServiceGC, isNull);
    expect(result.members!.length, isPositive);

    ClassHeapStats member = result.members![0];
    expect(member.instancesAccumulated, isNotNull);
    expect(member.instancesCurrent, isNotNull);
    expect(member.bytesCurrent, isNotNull);
    expect(member.accumulatedSize, isNotNull);

    // reset.
    result = await service.getAllocationProfile(isolateId, reset: true);
    final firstReset = result.dateLastAccumulatorReset;
    expect(firstReset, isNotNull);
    expect(result.dateLastServiceGC, isNull);
    expect(result.members!.length, isPositive);

    member = result.members![0];
    expect(member.instancesAccumulated, isNotNull);
    expect(member.instancesCurrent, isNotNull);
    expect(member.bytesCurrent, isNotNull);
    expect(member.accumulatedSize, isNotNull);

    await sleep(1000);

    result = await service.getAllocationProfile(isolateId, reset: true);
    final secondReset = result.dateLastAccumulatorReset;
    expect(secondReset, isNot(firstReset));

    // gc.
    result = await service.getAllocationProfile(isolateId, gc: true);
    expect(result.dateLastAccumulatorReset, secondReset);
    final firstGC = result.dateLastServiceGC;
    expect(firstGC, isNotNull);
    expect(result.members!.length, isPositive);

    member = result.members![0];
    expect(member.instancesAccumulated, isNotNull);
    expect(member.instancesCurrent, isNotNull);
    expect(member.bytesCurrent, isNotNull);
    expect(member.accumulatedSize, isNotNull);

    await sleep(1000);

    result = await service.getAllocationProfile(isolateId, gc: true);
    final secondGC = result.dateLastAccumulatorReset;
    expect(secondGC, isNot(firstGC));
  },
];

void main([args = const <String>[]]) => runIsolateTests(
      args,
      tests,
      'get_allocation_profile_rpc_test.dart',
    );
// Copyright (c) 2023, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

import 'common/service_test_common.dart';
import 'common/test_helper.dart';

// AUTOGENERATED START
//
// Update these constants by running:
//
// dart pkg/vm_service/test/update_line_numbers.dart pkg/vm_service/test/step_through_for_each_loop_test.dart
//
const LINE_A = 20;
// AUTOGENERATED END

const file = 'step_through_for_each_loop_test.dart';

void code()


 content: "\f01e\f01e"
}

.fa-duotone.fa-arrow-trend-down:after,
.fad.fa-arrow-trend-down:after {
    content: "\e097\e097"
}

.fa-duotone.fa-arrow-trend-up:after,
.fad.fa-arrow-trend-up:after {
    content: "\e098\e098"
}

.fa-duotone.fa-arrow-turn-down:after,
.fa-duotone.fa-level-down:after,
.fad.fa-arrow-turn-down:after,
.fad.fa-level-down:after {
    content: "\f149\f149"
}

.fa-duotone.fa-arrow-turn-down-left:after,
.fad.fa-arrow-turn-down-left:after {
    content: "\e2e1\e2e1"
}

.fa-duotone.fa-arrow-turn-down-right:after,
.fad.fa-arrow-turn-down-right:after {
    content: "\e3d6\e3d6"
}

.fa-duotone.fa-arrow-turn-up:after,
.fa-duotone.fa-level-up:after,
.fad.fa-arrow-turn-up:after,
.fad.fa-level-up:after {
    content: "\f148\f148"
}

.fa-duotone.fa-arrow-up:after,
.fad.fa-arrow-up:after {
    content: "\f062\f062"
}

.fa-duotone.fa-arrow-up-1-9:after,
.fa-duotone.fa-sort-numeric-up:after,
.fad.fa-arrow-up-1-9:after,
.fad.fa-sort-numeric-up:after {
    content: "\f163\f163"
}

.fa-duotone.fa-arrow-up-9-1:after,
.fa-duotone.fa-sort-numeric-up-alt:after,
.fad.fa-arrow-up-9-1:after,
.fad.fa-sort-numeric-up-alt:after {
    content: "\f887\f887"
}

.fa-duotone.fa-arrow-up-a-z:after,
.fa-duotone.fa-sort-alpha-up:after,
.fad.fa-arrow-up-a-z:after,
.fad.fa-sort-alpha-up:after {
    content: "\f15e\f15e"
}

.fa-duotone.fa-arrow-up-arrow-down:after,
.fa-duotone.fa-sort-up-down:after,
.fad.fa-arrow-up-arrow-down:after,
.fad.fa-sort-up-down:after {
    content: "\e099\e099"
}

.fa-duotone.fa-arrow-up-big-small:after,
.fa-duotone.fa-sort-size-up:after,
.fad.fa-arrow-up-big-small:after,
.fad.fa-sort-size-up:after {
    content: "\f88e\f88e"
}

.fa-duotone.fa-arrow-up-from-bracket:after,
.fad.fa-arrow-up-from-bracket:after {
    content: "\e09a\e09a"
}

.fa-duotone.fa-arrow-up-from-dotted-line:after,
.fad.fa-arrow-up-from-dotted-line:after {
    content: "\e09b\e09b"
}

.fa-duotone.fa-arrow-from-bottom:after,
.fa-duotone.fa-arrow-up-from-line:after,
.fad.fa-arrow-from-bottom:after,
.fad.fa-arrow-up-from-line:after {
    content: "\f


p,
        lineHeight = 20.sp,
        letterSpacing = 0.25.sp,
      ),
    bodySmall =
      TextStyle(
        fontFamily = Manrope,
        fontWeight = FontWeight.Normal,
        fontSize = 12.sp,
        lineHeight = 16.sp,
        letterSpacing = 0.4.sp,
      ),
    labelMedium =
      TextStyle(
        fontFamily = Manrope,
        fontWeight = FontWeight.Medium,
        fontSize = 12.sp,
        lineHeight = 16.sp,
        letterSpacing = 0.5.sp,
      ),
    labelSmall =
      TextStyle(
        fontFamily = Manrope,
        fontWeight = FontWeight.Medium,
        fontSize = 11.sp,
        lineHeight = 16.sp,
        letterSpacing = 0.5.sp,
      ),
  )
/*
 * Copyright © 2017-2020 WireGuard LLC.
 * Copyright © 2018-2020 Harsh Shandilya <msfjarvis@gmail.com>. All Rights Reserved.
 * SPDX-License-Identifier: Apache-2.0
 */
package com.wireguard.android.util

import android.content.res.Resources
import com.wireguard.android.Application
import com.wireguard.android.R
import java.net.InetAddress
import me.msfjarvis.viscerion.config.BadConfigException
import me.msfjarvis.viscerion.config.BadConfigException.Reason
import me.msfjarvis.viscerion.config.InetEndpoint
import me.msfjarvis.viscerion.config.InetNetwork
import me.msfjarvis.viscerion.config.ParseException
import me.msfjarvis.viscerion.crypto.Key.Format
import me.msfjarvis.viscerion.crypto.KeyFormatException
import me.msfjarvis.viscerion.crypto.KeyFormatException.Type

object ErrorMessages {
    private val BCE_REASON_MAP = mapOf(
        Reason.INVALID_KEY to R.string.bad_config_reason_invalid_key,
        Reason.INVALID_NUMBER to R.string.bad_config_reason_invalid_number,
        Reason.INVALID_VALUE to R.string.bad_config_reason_invalid_value,
        Reason.MISSING_ATTRIBUTE to R.string.bad_config_reason_missing_attribute,
        Reason.MISSING_SECTION to R.string.bad_config_reason_missing_section,
        Reason.MISSING_VALUE to R.string.bad_config_reason_missing_value,
        Reason.SYNTAX_ERROR to R.string.bad_config_reason_syntax_error,
        Reason.UNKNOWN_ATTRIBUTE to R.string.bad_config_reason_unknown_attribute,
        Reason.UNKNOWN_SECTION to R.string.bad_config_reason_unknown_section
    )

    private val KFE_FORMAT_MAP = mapOf(
        Format.BASE64 to R.string.key_length_explanation_base64,
        Format.BINARY to R.string.key_length_explanation_binary,
        Format.HEX to R.string.key_length_explanation_hex
    )

    private val KFE_TYPE_MAP = mapOf(
        Type.CONTENTS to R.string.key_contents_error,
        Type.LENGTH to R.string.key_length_error
    )

    private val PE_CLASS_MAP = mapOf<Class<*>, Int>(
        InetAddress::class.java to R.string.parse_error_inet_address,
        InetEndpoint::class.java to R.string.parse_error_inet_endpoint,
        InetNetwork::class.java to R.string.parse_error_inet_network,
        Int::class.java to R.string.parse_error_integer
    )

    operator fun get(throwable: Throwable?): String {
        val resources = Application.INSTANCE.resources
        if (throwable == null) {
            return resources.getString(R.string.unknown_error)
        }


r) {
          if ( ! order ) return '';
          var desc = this.Desc.isInstance(order);
          var baseOrder = desc ? order.arg1 : order;
          return prop.name === baseOrder.name ?
              this.Entity.create({ name: desc ? 'darr' : 'uarr' }) : '';
        }.bind(this, this.columns_[i]));

        e.start('td')
            .enableClass(this.myClass('sorting'), sorting$)
            .start('span')
                .addClass(this.myClass('sort-direction'))
                .add(sorting$)
            .end()
            .add(this.columns_[i].columnLabel)
            .on('click', this.tableView.sortBy.bind(this.tableView, this.columns_[i]))
            .end();
      }
      e.end();
    }
  ]
});

foam.CLASS({
  package: 'foam.u2',
  name: 'TableView',
  extends: 'foam.u2.Element',

  requires: [
    'foam.mlang.order.Desc',
    'foam.u2.TableBodySink',
    'foam.u2.TableHeader'
  ],

  exports: [
    'as tableView'
  ],

  css: `
    ^sorting {
      font-weight: bold;
    }

    ^sort-direction {
      display: none;
      margin-right: 8px;
    }
    ^sorting ^sort-direction {
      display: initial;
    }
  `,

  properties: [
    {
      class: 'Class',
      name: 'of',
      factory: function() { return this.data.of; }
    },
    [ 'nodeName', 'table' ],
    {
      name: 'columns_',
      expression: function(columns, of) {
        var cls = this.of;
        return columns.map(function(p) {
          // Lookup String values as Axiom names, otherwise,
          // treat the object as the column object itself.
          return typeof p === 'string' ?
              cls.getAxiomByName(p) :
              p ;
        });
      }
    },
    {
      // TODO: remove when all code ported
      name: 'properties',
      setter: function(_, ps) {
        console.warn("Deprecated use of TableView.properties. Use 'columns' instead.");
        this.columns = ps;
      }
    },
    {
      name: 'columns',
      expression: function(of) {
        if ( ! this.of ) return [];

        var tableColumns = this.of.getAxiomByName('tableColumns');

        if ( tableColumns ) return tableColumns.columns;

        return this.of.getAxiomsByClass(foam.core.Property)
            .filter(function(p) { return ! p.hidden; })
            .map(foam.core.Property.NAME.f);
      }
    },
    {
      name: 'config'
      // Map of property-name: {map of property overrides} for configuring properties
      // values include 'label', 'units', and 'view'
    },
    {
      class: 'foam.dao.DAOProperty',
      name: 'data'
    },
    {
      name: 'header',
      expression: function(columns_) {
        return this.TableHeader.create({
          columns_: columns_,
          sortOrder$: this.sortOrder$
        });
      }
    },
    {
      name: 'body',
      factory: function() { return this.E('tbody'); }
    },
    {
      name: 'sortOrder'
    },
    {
      name: 'selection'
    }
  ],

  methods: [
    function init() {
      this.SUPER();

      console.log('Deprecated use of foam.u2.TableView. Use foam.u2.view.TableView instead.');
    },

    function initE() {
      // Configure columns if 'config' set


 Fail if the resource requirements cannot be satisfied by any Fargate task size.
	if cpu == 0 {
		return 0, 0, fmt.Errorf("resource requirements (cpu:%v, memory:%v) are too high", rs.CPU, rs.Memory)
	}

	// Fargate task CPU size is specified in vCPU/1024s and memory size is specified in MiBs.
	return cpu, memory, nil
}
/*
Copyright 2020 Elotl Inc.

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 timeoutmap

import (
	"testing"
	"time"

	"github.com/stretchr/testify/assert"
)

// test timeout
// test timeout fall function
// tset checkin

// func makeRunningMap() *TimeoutMap {
// 	return
// }

func TestBasic(t *testing.T) {
	t.Parallel()
	m := New(true, make(chan struct{}))
	k := "key"
	v := "value"
	m.Add(k, v, 1*time.Second, Noop)
	iface, exists := m.Get(k)
	assert.True(t, exists)
	value, worked := iface.(string)
	assert.True(t, worked)
	assert.Equal(t, v, value)
}

func TestTimeoutBasic(t *testing.T) {
	t.Parallel()
	m := New(true, make(chan struct{}))
	k := "key"
	v := "value"
	m.Add(k, v, 1*time.Millisecond, Noop)
	go m.Start(100 * time.Millisecond)
	time.Sleep(250 * time.Millisecond)
	_, exists := m.Get(k)
	assert.False(t, exists)
}

func TestTimeoutCallFunc(t *testing.T) {
	t.Parallel()
	m := New(true, make(chan struct{}))
	k := "key"
	v := "value"
	funcCalled := false
	m.Add(k, v, 1*time.Millisecond, func(obj interface{}) {
		value, worked := obj.(string)
		assert.True(t, worked)
		assert.Equal(t, v, value)
		funcCalled = true
	})
	go m.Start(100 * time.Millisecond)
	time.Sleep(250 * time.Millisecond)
	_, exists := m.Get(k)
	assert.False(t, exists)
	assert.True(t, funcCalled)
}

func TestCheckin(t *testing.T) {
	t.Parallel()
	m := New(true, make(chan struct{}))
	k := "key"
	v := "value"
	funcCalled := false
	m.Add(k, v, 200*time.Millisecond, func(obj interface{}) {
		funcCalled = true
	})
	go m.Start(100 * time.Millisecond)
	time.Sleep(100 * time.Millisecond)
	m.Checkin(k)
	time.Sleep(100 * time.Millisecond)
	m.Checkin(k)
	time.Sleep(100 * time.Millisecond)
	m.Checkin(k)
	time.Sleep(100 * time.Millisecond)
	m.Checkin(k)
	assert.False(t, funcCalled)
	_, exists := m.Get(k)
	assert.True(t, exists)
}
/*
Copyright 2020 Elotl Inc.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance wi


Reporter = reporting => {
  if (reporting === 'none') {
    return makeReportPrinter(mute);
  }
  if (
    reporting === 'console' ||
    globalThis.window === globalThis ||
    globalThis.importScripts !== undefined
  ) {
    return console;
  }
  if (globalThis.console !== undefined) {
    // On Node.js, we send all feedback to stderr, regardless of purported level.
    const console = globalThis.console;
    const error = functionBind(console.error, console);
    return makeReportPrinter(error);
  }
  if (globalThis.print !== undefined) {
    return makeReportPrinter(globalThis.print);
  }
  return makeReportPrinter(mute);
};

/**
 * @param {string} groupLabel
 * @param {GroupReporter} console
 * @param {(internalConsole: Reporter) => void} callback
 */$h_once.chooseReporter(chooseReporter);
       const reportInGroup = (groupLabel, console, callback) => {
  const { warn, error, groupCollapsed, groupEnd } = console;
  const grouping = groupCollapsed && groupEnd;
  let groupStarted = false;
  try {
    return callback({
      warn(...args) {
        if (grouping && !groupStarted) {
          groupCollapsed(groupLabel);
          groupStarted = true;
        }
        warn(...args);
      },
      error(...args) {
        if (grouping && !groupStarted) {
          groupCollapsed(groupLabel);
          groupStarted = true;
        }
        error(...args);
      },
    });
  } finally {
    if (grouping && groupStarted) {
      groupEnd();
      groupStarted = false;
    }
  }
};$h_once.reportInGroup(reportInGroup);
})()
,
// === 56. ses ./src/lockdown.js ===
({imports:$h_imports,liveVar:$h_live,onceVar:$h_once,import:$h_import,importMeta:$h____meta})=>(function(){'use strict';let getenv,FERAL_FUNCTION,FERAL_EVAL,TypeError,arrayFilter,globalThis,is,ownKeys,stringSplit,noEvalEvaluate,getOwnPropertyNames,getPrototypeOf,makeHardener,makeIntrinsicsCollector,removeUnpermittedIntrinsics,tameFunctionConstructors,tameDateConstructor,tameMathObject,tameRegExpConstructor,enablePropertyOverrides,tameLocaleMethods,setGlobalObjectConstantProperties,setGlobalObjectMutableProperties,setGlobalObjectEvaluators,makeSafeEvaluator,initialGlobalPropertyNames,tameFunctionToString,tameDomains,tameModuleSource,tameConsole,tameErrorConstructor,assert,makeAssert,getAnonymousIntrinsics,makeCompartmentConstructor,tameHarden,tameSymbolConstructor,tameFauxDataProperties,tameRegeneratorRuntime,shimArrayBufferTransfer,reportInGroup,chooseReporter;$h_imports([["@endo/env-options", [["getEnvironmentOption",[$h_a => (getenv = $h_a)]]]],["@endo/immutable-arraybuffer/shim.js", []],["./commons.js", [["FERAL_FUNCTION",[$h_a => (FERAL_FUNCTION = $h_a)]],["FERAL_EVAL",[$h_a => (FERAL_EVAL = $h_a)]],["TypeError",[$h_a => (TypeError = $h_a)]],["arrayFilter",[$h_a => (arrayFilter = $h_a)]],["globalThis",[$h_a => (globalThis = $h_a)]],["is",[$h_a => (is = $h_a)]],["ownKeys",[$h_a => (ownKeys = $h_a)]],["stringSplit",[$h_a => (stringSplit = $h_a)]],["noEvalEvaluate",[$h_a => (noEvalEvaluate = $h_a)]],["getOwnPropertyNames",[$h_a => (getOwnPropertyNames


055908203125
				],
				[
					13.913438585069457,
					1.4286295572916856
				],
				[
					15.217827690972285,
					2.1119181315104356
				],
				[
					15.217827690972285,
					2.1119181315104356
				]
			],
			"pressures": [
				0.2063492238521576,
				0.3196581304073334,
				0.3540903627872467,
				0.3819292187690735,
				0.406349241733551,
				0.4173382520675659,
				0.42002445459365845,
				0.41489624977111816,
				0.39609283208847046,
				0.3321123421192169,
				0.1953602135181427,
				0.06568986922502518,
				0
			],
			"simulatePressure": false,
			"lastCommittedPoint": [
				15.217827690972285,
				2.1119181315104356
			]
		},
		{
			"id": "xt69F2rLxJUo6_AjCDV_J",
			"type": "freedraw",
			"x": 132.1274050509992,
			"y": -246.7866677327287,
			"width": 12.484809027777828,
			"height": 13.044026692708314,
			"angle": 0,
			"strokeColor": "#1e1e1e",
			"backgroundColor": "transparent",
			"fillStyle": "solid",
			"strokeWidth": 0.5,
			"strokeStyle": "solid",
			"roughness": 1,
			"opacity": 100,
			"groupIds": [],
			"frameId": null,
			"roundness": null,
			"seed": 1214190050,
			"version": 152,
			"versionNonce": 2053073406,
			"isDeleted": false,
			"boundElements": null,
			"updated": 1705001739970,
			"link": null,
			"locked": false,
			"points": [
				[
					0,
					0
				],
				[
					-0.37258572048619953,
					0
				],
				[
					-0.5589463975694571,
					0
				],
				[
					-0.6833224826389142,
					0
				],
				[
					-0.9315999348958712,
					-0.12424045138891415
				],
				[
					-1.366441514756957,
					-0.3105333116319571
				],
				[
					-1.9254557291667425,
					-0.49686008029516415
				],
				[
					-2.484605577256957,
					-0.6832207573784785
				],
				[
					-3.4161376953125,
					-0.6832207573784785
				],
				[
					-4.844835069444457,
					-0.3105333116319571
				],
				[
					-6.273328993055657,
					1.1802164713541856
				],
				[
					-7.577853732638914,
					2.8572930230034785
				],
				[
					-8.447401258680657,
					4.844970703125
				],
				[
					-9.00634765625,
					6.956821017795107
				],
				[
					-9.1927761501737,
					9.068739149305543
				],
				[
					-8.819986979166742,
					10.87005615234375
				]


 .label {
    position: absolute;
    bottom: 10px;
    right: 10px;
    z-index: 2;
}

.overlay-element {
    height: 34px;
    line-height: 34px;
    padding: 0 10px;
    text-shadow: none;
    background: #222;
    color: #fff;
    border: 2px solid #fff;
    font-size: 14px;
}

#current-slide {
    position: absolute;
    width: 60%;
    height: 100%;
    top: 0;
    left: 0;
    padding-right: 0;
}

#upcoming-slide {
    position: absolute;
    width: 40%;
    height: 40%;
    right: 0;
    top: 0;
}

/* Speaker controls */
#speaker-controls {
    right: 0;
    width: 40%;
    overflow: auto;
    font-size: 18px;
}

.speaker-controls-time .label,
.speaker-controls-pace .label,
.speaker-controls-notes .label {
    text-transform: uppercase;
    font-weight: normal;
    font-size: 0.66em;
    opacity: 0.3;
    margin: 0;
}

.speaker-controls-time {
    border-bottom: 1px solid rgba( 200, 200, 200, 0.5 );
    margin-bottom: 10px;
    padding: 10px 16px;
    padding-bottom: 20px;
    cursor: pointer;
}

.speaker-controls-time .reset-button {
    text-decoration: none;
}

.speaker-controls-time:hover .reset-button {
    opacity: 1;
}

.speaker-controls-time .timer,
.speaker-controls-time .clock,
.speaker-controls-time .slide-count {
    font-size: 1.9em;
}

.speaker-controls-time span.mute {
    opacity: 0.3;
}

.speaker-controls-notes {
    width: 40%;
    float: right;
    padding: 1.2%;
    margin-top: 0.6%;
}

.speaker-controls-notes .value {
    margin-top: 5px;
    line-height: 1.4;
    font-size: 28px;
}

.clear {
    clear: both;
}

body {
    background: #222;
    color: #fff;
    margin: 0;
}

#slide-container {
    width: 60%;
    float: left;
}

#current-slide-container,
#upcoming-slide-container,
.speaker-controls-time,
.speaker-controls-notes {
    box-sizing: border-box;
}

#current-slide-container {
    padding: 1%;
}

#upcoming-slide-container {
    width: 70%;
    padding-left: 1%;
    padding-bottom: 1%;
    float: left;
}

#current-slide,
#upcoming-slide {
    overflow: hidden;
    padding-top: 56.25%;
    position: relative;
    width: auto;
    height: auto;
    top: auto;
    left: auto;
}

#current-slide iframe,
#upcoming-slide if


IM), dtype=dtype, device=device, requires_grad=True)
        k = torch.randn((BATCH, H, N_CTX, HEAD_DIM), dtype=dtype, device=device, requires_grad=True)
        v = torch.randn((BATCH, H, N_CTX, HEAD_DIM), dtype=dtype, device=device, requires_grad=True)
        if mode == "fwd" and "fp8" in provider:
            q = q.to(torch.float8_e5m2)
            k = k.to(torch.float8_e5m2)
            v = v.permute(0, 1, 3, 2).contiguous()
            v = v.permute(0, 1, 3, 2)
            v = v.to(torch.float8_e5m2)
        sm_scale = 1.3
        fn = lambda: attention(q, k, v, sm_scale)
        if mode == "bwd":
            o = fn()
            do = torch.randn_like(o)
            fn = lambda: o.backward(do, retain_graph=True)
        ms = triton.testing.do_bench(fn)

    if provider == "flash":
        qkv = torch.randn((BATCH, N_CTX, 3, H, HEAD_DIM), dtype=dtype, device=device, requires_grad=True)
        fn = lambda: flash_attn_func(qkv)
        if mode == "bwd":
            o = fn()
            do = torch.randn_like(o)
            fn = lambda: o.backward(do, retain_graph=True)
        ms = triton.testing.do_bench(fn)
    flops_per_matmul = 2.0 * BATCH * H * N_CTX * N_CTX * HEAD_DIM
    total_flops = 2 * flops_per_matmul
    if mode == "bwd":
        total_flops *= 2.5  # 2.0(bwd) + 0.5(recompute)
    return total_flops * 1e-12 / (ms * 1e-3)

if __name__ == "__main__":
    if is_blackwell():
        print("Running benchmarks...")
        bench_flash_attention.run(print_data=True)
    else:
        print("Skipping benchmarks, no Blackwell GPU found.")


C832		; if carry set do BREAK instead of just END

;***********************************************************************************;
;
; perform END

LAB_C831
	CLC				; clear carry
LAB_C832
	BNE	LAB_C870		; return if wasn't CTRL-C

	LDA	LAB_7A		; get BASIC execute pointer low byte
	LDY	LAB_7B		; get BASIC execute pointer high byte
	LDX	LAB_3A		; get current line number high byte
	INX				; increment it
	BEQ	LAB_C849		; branch if was immediate mode

	STA	LAB_3D		; save continue pointer low byte
	STY	LAB_3E		; save continue pointer high byte
	LDA	LAB_39		; get current line number low byte
	LDY	LAB_3A		; get current line number high byte
	STA	LAB_3B		; save break line number low byte
	STY	LAB_3C		; save break line number high byte
LAB_C849
	PLA				; dump return address low byte
	PLA				; dump return address high byte
LAB_C84B
	LDA	#<LAB_C381		; set [CR][LF]"BREAK" pointer low byte
	LDY	#>LAB_C381		; set [CR][LF]"BREAK" pointer high byte
	BCC	LAB_C854		; branch if was program end

	JMP	LAB_C469		; print string and do warm start

LAB_C854
	JMP	LAB_C474		; do warm start

;***********************************************************************************;
;
; perform CONT

LAB_C857
	BNE	LAB_C870		; exit if following byte to allow syntax error

	LDX	#$1A			; error code $1A, can't continue error
	LDY	LAB_3E		; get continue pointer high byte
	BNE	LAB_C862		; go do continue if we can

	JMP	LAB_C437		; else do error #X then warm start

					; we can continue so ...
LAB_C862
	LDA	LAB_3D		; get continue pointer low byte
	STA	LAB_7A		; save BASIC execute pointer low byte
	STY	LAB_7B		; save BASIC execute pointer high byte
	LDA	LAB_3B		; get break line low byte
	LDY	LAB_3C		; get break line high byte
	STA	LAB_39		; set current line number low byte
	STY	LAB_3A		; set current line number high byte
LAB_C870
	RTS

;***********************************************************************************;
;
; perform RUN

LAB_C871
	PHP				; save status
	LDA	#$00			; no control or kernal messages
	JSR	LAB_FF90		; control kernal messages
	PLP				; restore status
	BNE	LAB_C87D		; branch if RUN n

	JMP	LAB_C659		; reset execution to start, clear variables, flush stack
					; and return
LAB_C87D
	JSR	LAB_C660		; go do "CLEAR"
	JMP	LAB_C897		; get n and do GOTO n

;***********************************************************************************;
;
; perform GOSUB

LAB_C883
	LDA	#$03			; need 6 bytes for GOSUB
	JSR	LAB_C3FB		; check room on stack for 2*A bytes
	LDA	LAB_7B		; get BASIC execute pointer high byte
	PHA				; save it
	LDA	LAB_7A		; get BASIC execute pointer low byte
	PHA				; save it
	LDA	LAB_3A		; get current line number high byte
	PHA				; save it
	LDA	LAB_39		; get current line number low byte
	PHA				; save it
	LDA	#TK_GOSUB		; token for GOSUB
	PHA				; save it
LAB_C897
	JSR	LAB_0079		; scan memory
	JSR


?} sw {:?} sh {:?} dx {:?} dy {:?} dw {:?} dh {:?} flip_x {:?} flip_y {:?}", sx, sy, sw, sh, dx, dy, dw, dh, flip_x, flip_y);

        let mut v = Vec::new();

        for y in sy..sy + sh {
            for x in sx..sx + sw {
                v.push(self.sget(x, y));
            }
        }

        debug!("SSPR V {:?} {:?}", v.len(), v);

        let mut x2;
        let mut y2;

        let w1 = sw;
        let w2 = dw;

        let h1 = sh;
        let h2 = dh;

        let x_ratio;
        let y_ratio;

        let mut ret = Vec::with_capacity((w2 * h2) as usize);

        x_ratio = ((w1 << 16) / w2) + 1;
        y_ratio = ((h1 << 16) / h2) + 1;

        debug!("SSPR H1 {:?} W1 {:?} H2 {:?} W2 {:?} X RATIO {:?} Y RATIO {:?}", h1, w1, h2, w2, x_ratio, y_ratio);

        for i in 0..h2 {
            for j in 0..w2 {
                x2 = (j * x_ratio) >> 16;
                y2 = (i * y_ratio) >> 16;
                ret.insert((i * w2 + j) as usize, *v.get((y2 * w1 + x2) as usize).unwrap());
            }
        }

        debug!("SSPR OUTPUT RET {:?} {:?}", ret.len(), ret);

        if flip_x {
            for i in 0..w2 / 2 {
                for j in 0..h2 {
                    let tmp = ret[(i + j * w2) as usize];
                    ret[(i + j * w2) as usize] = ret[((w2 - (i + 1)) + j * w2) as usize];
                    ret[((w2 - (i + 1)) + j * w2) as usize] = tmp;
                }
            }
        }

        if flip_y {
            for i in 0..h2 / 2 {
                for j in 0..w2 {
                    let tmp = ret[(j + i * w2) as usize];
                    ret[(j + i * w2) as usize] = ret[(j + (h2 - (i + 1)) * w2) as usize];
                    ret[(j + (h2 - (i + 1)) * w2) as usize] = tmp;
                }
            }
        }

        let mut idx = 0;
        for j in 0..h2 {
            for i in 0..w2 {
                let d: u8 = *ret.get(idx).unwrap();
                idx += 1;
                if d != 0 {
                    if !self.is_transparent(d as u32) {
                        self.putpixel_(i as i32 + dx, j as i32 + dy, d as u32);
                    }
                }
            }
        }
    }

    pub fn is_transparent(&mut self, value: u32) -> bool {
        match self.transparency.get(&(value as u32)) {
            Some(&1) => {
                return true;
            },
            Some(&_) => (),
            None => (),
        }
        return false;
    }

    pub fn pal(&mut self, c0: i32, c1: i32) {
        if c0 < 0 || c1 < 0 {
            self._reset_colors();
        } else {
            self.colors.insert(c0 as u32, c1 as u32);
        }
    }

    pub fn palt(&mut self, c: i32, t: bool) {
        if c == -1 {
            self._reset_transparency();
        } else {
            self.transparency.insert(c as u32, t as u8);
        }
    }

    pub fn peek(&mut self, addr: u32) -> u32 {
        return self


),%r9
	movq	16(%rsi),%r10
	movq	24(%rsi),%r11
	movq	%rax,%r8
	movq	L$poly+8(%rip),%r12

	movq	%rax,%rcx
	shlq	$32,%r8
	mulq	%r13
	shrq	$32,%rcx
	addq	%r8,%r9
	adcq	%rcx,%r10
	adcq	%rax,%r11
	movq	%r9,%rax
	adcq	$0,%rdx

	movq	%r9,%rcx
	shlq	$32,%r9
	movq	%rdx,%r8
	mulq	%r13
	shrq	$32,%rcx
	addq	%r9,%r10
	adcq	%rcx,%r11
	adcq	%rax,%r8
	movq	%r10,%rax
	adcq	$0,%rdx

	movq	%r10,%rcx
	shlq	$32,%r10
	movq	%rdx,%r9
	mulq	%r13
	shrq	$32,%rcx
	addq	%r10,%r11
	adcq	%rcx,%r8
	adcq	%rax,%r9
	movq	%r11,%rax
	adcq	$0,%rdx

	movq	%r11,%rcx
	shlq	$32,%r11
	movq	%rdx,%r10
	mulq	%r13
	shrq	$32,%rcx
	addq	%r11,%r8
	adcq	%rcx,%r9
	movq	%r8,%rcx
	adcq	%rax,%r10
	movq	%r9,%rsi
	adcq	$0,%rdx

	subq	$-1,%r8
	movq	%r10,%rax
	sbbq	%r12,%r9
	sbbq	$0,%r10
	movq	%rdx,%r11
	sbbq	%r13,%rdx
	sbbq	%r13,%r13

	cmovnzq	%rcx,%r8
	cmovnzq	%rsi,%r9
	movq	%r8,0(%rdi)
	cmovnzq	%rax,%r10
	movq	%r9,8(%rdi)
	cmovzq	%rdx,%r11
	movq	%r10,16(%rdi)
	movq	%r11,24(%rdi)

	popq	%r13
	popq	%r12
	.byte	0xf3,0xc3

.globl	_ecp_nistz256_select_w5
.private_extern _ecp_nistz256_select_w5

.p2align	5
_ecp_nistz256_select_w5:
	movdqa	L$One(%rip),%xmm0
	movd	%edx,%xmm1

	pxor	%xmm2,%xmm2
	pxor	%xmm3,%xmm3
	pxor	%xmm4,%xmm4
	pxor	%xmm5,%xmm5
	pxor	%xmm6,%xmm6
	pxor	%xmm7,%xmm7

	movdqa	%xmm0,%xmm8
	pshufd	$0,%xmm1,%xmm1

	movq	$16,%rax
L$select_loop_sse_w5:

	movdqa	%xmm8,%xmm15
	paddd	%xmm0,%xmm8
	pcmpeqd	%xmm1,%xmm15

	movdqa	0(%rsi),%xmm9
	movdqa	16(%rsi),%xmm10
	movdqa	32(%rsi),%xmm11
	movdqa	48(%rsi),%xmm12


 0x01, 0x20, 0x01, 0x28,
	0x0d, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18,
	0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01,
	0x42, 0x1d, 0x5a, 0x1b, 0x47, 0x6f, 0x2d, 0x47, 0x72, 0x61, 0x73, 0x73, 0x63, 0x75, 0x74, 0x74,
	0x65, 0x72, 0x2f, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x2f, 0x70, 0x62, 0x62,
	0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
}

var (
	file_proto_SceneGalleryHomeSeekFurnitureInfo_proto_rawDescOnce sync.Once
	file_proto_SceneGalleryHomeSeekFurnitureInfo_proto_rawDescData = file_proto_SceneGalleryHomeSeekFurnitureInfo_proto_rawDesc
)

func file_proto_SceneGalleryHomeSeekFurnitureInfo_proto_rawDescGZIP() []byte {
	file_proto_SceneGalleryHomeSeekFurnitureInfo_proto_rawDescOnce.Do(func() {
		file_proto_SceneGalleryHomeSeekFurnitureInfo_proto_rawDescData = protoimpl.X.CompressGZIP(file_proto_SceneGalleryHomeSeekFurnitureInfo_proto_rawDescData)
	})
	return file_proto_SceneGalleryHomeSeekFurnitureInfo_proto_rawDescData
}

var file_proto_SceneGalleryHomeSeekFurnitureInfo_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
var file_proto_SceneGalleryHomeSeekFurnitureInfo_proto_goTypes = []interface{}{
	(*SceneGalleryHomeSeekFurnitureInfo)(nil), // 0: SceneGalleryHomeSeekFurnitureInfo
	nil, // 1: SceneGalleryHomeSeekFurnitureInfo.PlayerScoreMapEntry
}
var file_proto_SceneGalleryHomeSeekFurnitureInfo_proto_depIdxs = []int32{
	1, // 0: SceneGalleryHomeSeekFurnitureInfo.player_score_map:type_name -> SceneGalleryHomeSeekFurnitureInfo.PlayerScoreMapEntry
	1, // [1:1] is the sub-list for method output_type
	1, // [1:1] is the sub-list for method input


ut, -webkit-box-shadow 0.15s ease-in-out}@media (prefers-reduced-motion: reduce){.custom-switch .custom-control-label::after{-webkit-transition:none;transition:none}}.custom-switch .custom-control-input:checked ~ .custom-control-label::after{background-color:#fff;-webkit-transform:translateX(0.75rem);transform:translateX(0.75rem)}.custom-switch .custom-control-input:disabled:checked ~ .custom-control-label::before{background-color:rgba(39,128,227,0.5)}.custom-select{display:inline-block;width:100%;height:calc(1.5em + 0.75rem + 2px);padding:0.375rem 1.75rem 0.375rem 0.75rem;font-size:0.9375rem;font-weight:400;line-height:1.5;color:#495057;vertical-align:middle;background:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 4 5'%3e%3cpath fill='%23373a3c' d='M2 0L0 2h4zm0 5L0 3h4z'/%3e%3c/svg%3e") no-repeat right 0.75rem center/8px 10px;background-color:#fff;border:1px solid #ced4da;border-radius:0;-webkit-appearance:none;-moz-appearance:none;appearance:none}.custom-select:focus{border-color:#98c2f2;outline:0;-webkit-box-shadow:0 0 0 0.2rem rgba(39,128,227,0.25);box-shadow:0 0 0 0.2rem rgba(39,128,227,0.25)}.custom-select:focus::-ms-value{color:#495057;background-color:#fff}.custom-select[multiple],.custom-select[size]:not([size="1"]){height:auto;padding-right:0.75rem;background-image:none}.custom-select:disabled{color:#868e96;background-color:#e9ecef}.custom-select::-ms-expand{display:none}.custom-select-sm{height:calc(1.5em + 0.5rem + 2px);padding-top:0.25rem;padding-bottom:0.25rem;padding-left:0.5rem;font-size:0.8203125rem}.custom-select-lg{height:calc(1.5em + 1rem + 2px);padding-top:0.5rem;padding-bottom:0.5rem;padding-left:1rem;font-size:1.171875rem}.custom-file{position:relative;display:inline-block;width:100%;height:calc(1.5em + 0.75rem + 2px);margin-bottom:0}.custom-file-input{position:relative;z-index:2;width:100%;height:calc(1.5em + 0.75rem + 2px);margin:0;opacity:0}.custom-file-input:focus ~ .custom-file-label{border-color:#98c2f2;-webkit-box-shadow:0 0 0 0.2rem rgba(39,128,227,0.25);box-shadow:0 0 0 0.2rem rgba(39,128,227,0.25)}.custom-file-input:disabled ~ .custom-file-label{background-color:#e9ecef}.custom-file-input:lang(en) ~ .custom-file-label::after{content:"Browse"}.custom-file-input ~ .custom-file-label[data-browse]::after{content:attr(data-browse)}.custom-file-label{position:absolute;top:0;right:0;left:0;z-index:1;height:calc(1.5em + 0.75rem + 2px);padding:0.375rem 0.75rem;font-weight:400;line-height:1.5;color:#495057;background-color:#fff;border:1px solid #ced4da}.custom-file-label::after{position:absolute;top:0;right:0


--
-- tests/test_clang.lua
-- Automated test suite for the GCC toolset interface.
-- Copyright (c) 2009-2013 Jason Perkins and the Premake project
--

	local p = premake
	local suite = test.declare("tools_clang")

	local clang = p.tools.clang
	local project = p.project

--
-- Setup/teardown
--

	local wks, prj, cfg

	function suite.setup()
		wks, prj = test.createWorkspace()
		system "Linux"
	end

	local function prepare()
		cfg = test.getconfig(prj, "Debug")
	end

--
-- Check the selection of tools based on the target system.
--

	function suite.tools_onDefaults()
		prepare()
		test.isequal("clang", clang.gettoolname(cfg, "cc"))
		test.isequal("clang++", clang.gettoolname(cfg, "cxx"))
		test.isequal("ar", clang.gettoolname(cfg, "ar"))
		test.isequal("windres", clang.gettoolname(cfg, "rc"))
	end

	function suite.tools_forVersion()
		toolset "clang-16"
		prepare()
		test.isequal("clang-16", clang.gettoolname(cfg, "cc"))
		test.isequal("clang++-16", clang.gettoolname(cfg, "cxx"))
		test.isequal("ar-16", clang.gettoolname(cfg, "ar"))
		test.isequal("windres-16", clang.gettoolname(cfg, "rc"))
	end

--
-- Check Mac OS X deployment target flags
--

	function suite.cflags_macosx_systemversion()
		system "MacOSX"
		systemversion "10.9"
		prepare()
		test.contains({ "-mmacosx-version-min=10.9" }, clang.getcflags(cfg))
	end

	function suite.cxxflags_macosx_s


6639
	STL B, 1, *(04653h)			; 6640
	STL B, 1, *AR7				; 6641
	STL B, 1, *AR7-				; 6642
	STL B, 1, *AR7+				; 6643
	STL B, 1, *+AR7				; 6644
	STL B, 1, *AR7-0B			; 6645
	STL B, 1, *AR7-0			; 6646
	STL B, 1, *AR7+0			; 6647
	STL B, 1, *AR7+0B			; 6648
	STL B, 1, *AR7-%			; 6649
	STL B, 1, *AR7-0%			; 6650
	STL B, 1, *AR7+%			; 6651
	STL B, 1, *AR7+0%			; 6652
	STL B, 1, *AR7(04654h)			; 6653
	STL B, 1, *+AR7(04655h)			; 6654
	STL B, 1, *+AR7(04656h)%		; 6655
	STL B, 1, *(04657h)			; 6656
	STL B, 2, *AR0				; 6657
	STL B, 2, *AR0-				; 6658
	STL B, 2, *AR0+				; 6659
	STL B, 2, *+AR0				; 6660
	STL B, 2, *AR0-0B			; 6661
	STL B, 2, *AR0-0			; 6662
	STL B, 2, *AR0+0			; 6663
	STL B, 2, *AR0+0B			; 6664
	STL B, 2, *AR0-%			; 6665
	STL B, 2, *AR0-0%			; 6666
	STL B, 2, *AR0+%			; 6667
	STL B, 2, *AR0+0%			; 6668
	STL B, 2, *AR0(04658h)			; 6669
	STL B, 2, *+AR0(04659h)			; 6670
	STL B, 2, *+AR0(0465Ah)%		; 6671
	STL B, 2, *(0465Bh)			; 6672
	STL B, 2, *AR1				; 6673
	STL B, 2, *AR1-				; 6674
	STL B, 2, *AR1+				; 6675
	STL B, 2, *+AR1				; 6676
	STL B, 2, *AR1-0B			; 6677
	STL B, 2, *AR1-0			; 6678
	STL B, 2, *AR1+0			; 6679
	STL B, 2, *AR1+0B			; 6680
	STL B, 2, *AR1-%			; 6681
	STL B, 2, *AR1-0%			; 6682
	STL B, 2, *AR1+%			; 6683
	STL B, 2, *AR1+0%			; 6684
	STL B, 2, *AR1(0465Ch)			; 6685
	STL B, 2, *+AR1(0465Dh)			; 6686
	STL B, 2, *+AR1(0465Eh)%		; 6687
	STL B, 2, *(0465Fh)			; 6688
	STL B, 2, *AR2				; 6689
	STL B, 2, *AR2-				; 6690
	STL B, 2, *AR2+				; 6691
	STL B, 2, *+AR2				; 6692
	STL B, 2, *AR2-0B


ion.West);
      expect(myRobot.getPosition).toEqual({ x: 4, y: 0 });
    });
    it(`shouldn't move towards West when there is no space`, () => {
      myRobot.runCmd("Place 0,0,West");
      myRobot.runCmd("Move");
      expect(myRobot.getDirection).toBe(Direction.West);
      expect(myRobot.getPosition).toEqual({ x: 0, y: 0 });
    });

    it(`should console.log location and direction`, () => {
      const consoleLogSpy = jest.spyOn(console, "log");

      myRobot.runCmd("Place 1,2,West");
      myRobot.runCmd("Report");

      expect(consoleLogSpy).toHaveBeenCalledWith("1,2,WEST");
    });

    it(`should face East when turn Right from North`, () => {
      myRobot.runCmd("Place 0,0,North");
      myRobot.runCmd("Right");
      expect(myRobot.getPosition).toEqual({ x: 0, y: 0 });
      expect(myRobot.getDirection).toBe(Direction.East);
    });
    it(`should face South when turn Right from East`, () => {
      myRobot.runCmd("Place 0,0,East");
      myRobot.runCmd("Right");
      expect(myRobot.getPosition).toEqual({ x: 0, y: 0 });
      expect(myRobot.getDirection).toBe(Direction.South);
    });
    it(`should face West when turn Right from South`, () => {
      myRobot.runCmd("Place 0,0,South");
      myRobot.runCmd("Right");
      expect(myRobot.getPosition).toEqual({ x: 0, y: 0 });
      expect(myRobot.getDirection).toBe(Direction.West);
    });
    it(`should face North when turn Right from West`, () => {
      myRobot.runCmd("Place 0,0,West");
      myRobot.runCmd("Right");
      expect(myRobot.getPosition).toEqual({ x: 0, y: 0 });
      expect(myRobot.getDirection).toBe(Direction.North);
    });

    it(`should face West when turn Left from North`, () => {
      myRobot.runCmd("Place 0,0,North");
      myRobot.runCmd("Left");
      expect(myRobot.getPosition).toEqual({ x: 0, y: 0 });
      expect(myRobot.getDirection).toBe(Direction.West);
    });
    it(`should face South when turn Left from West`, () => {
      myRobot.runCmd("Place 0,0,West");
      myRobot.runCmd("Left");
      expect(myRobot.getPosition).toEqual({ x: 0, y: 0 });
      expect(myRobot.getDirection).toBe(Direction.South);
    });
    it(`should face East when turn Left from South`, () => {
      myRobot.runCmd("Place 0,0,South");
      myRobot.runCmd("Left");
      expect(myRobot.getPosition).toEqual({ x: 0, y: 0 });
      expect(myRobot.getDirection).toBe(Direction.East);
    });
    it(`should face North when turn Left from East`, () => {
      myRobot.runCmd("Place 0,0,East");
      myRobot.runCmd("Left");
      expect(myRobot.getPosition).toEqual({ x: 0, y: 0 });
      expect(myRobot.getDirection).toBe(Direction.North);
    });
  });
});
import { Injectable } from "@angular/core";
import * as d3 from "d3";

@Injectable({
  providedIn: "root"
})

export class D3Service {
  public d3 = d3;
  /**
   * Generates random letter string with specified length
   * @param length: number
   */
  public generateId(length: any): string {
    let result = "";
    const characters = "