      }
        #[test]
        fn tuple() {
            parse!(r#"{}"#);
            parse!(r#"{a_variable: 1, 'cow': 'moo', 'a': NULL}"#);
        }
    }

    mod expr {
        use super::*;

        #[test]
        fn or_simple() {
            parse!(r#"TRUE OR FALSE"#);
        }

        #[test]
        fn or() {
            parse!(r#"t1.super OR test(t2.name, t1.name)"#);
        }

        #[test]
        fn and_simple() {
            parse!(r#"TRUE and FALSE"#);
        }

        #[test]
        fn and() {
            parse!(r#"test(t2.name, t1.name) AND t1.id = t2.id"#);
        }

        #[test]
        fn or_and() {
            parse!(r#"t1.super OR test(t2.name, t1.name) AND t1.id = t2.id"#);
        }

        #[test]
        fn infix() {
            parse!(r#"1 + -2 * +3 % 4^5 / 6 - 7  <= 3.14 AND 'foo' || 'bar' LIKE '%oba%'"#);
        }

        #[test]
        fn expr_in() {
            parse!(r#"a in (1,2,3,4)"#);
            parse!(r#"a in [1,2,3,4]"#);
        }

        #[test]
        fn expr_between() {
            parse!(r#"a between 2 and 3"#);
        }
    }

    mod pathexpr {
        use super::*;

        #[test]
        fn nested() {
            parse!(r#"a.b"#);
            parse!(r#"a.b.c['item']."d"[5].e['s'].f[1+2]"#);
            parse!(r#"a.b.*"#);
            parse!(r#"a.b[*]"#);
            parse!(r#"@a.b[*]"#);
            parse!(r#"@"a".b[*]"#);
            parse!(r#"tables.items[*].product.*.nest"#);
        }

        #[test]
        fn tuple() {
            parse!(r#"{'a':1 , 'data': 2}.a"#);
            parse!(r#"{'a':1 , 'data': 2}.'a'"#);
            parse!(r#"{'A':1 , 'data': 2}."A""#);
            parse!(r#"{'A':1 , 'data': 2}['a']"#);
            parse!(r#"{'attr': 1, 'b':2}[v || w]"#);
            parse!(r#"{'a':1, 'b':2}.*"#);
        }

        #[test]
        fn array() {
            parse!(r#"[1,2,3][0]"#);
            parse!(r#"[1,2,3][1 + 1]"#);
            parse!(r#"[1,2,3][*]"#);
        }

        #[test]
        fn query() {
            parse!(r#"(SELECT a FROM table).a"#);
            parse!(r#"(SELECT a FROM table).'a'"#);
            parse!(r#"(SELECT a FROM table)."a""#);
            parse!(r#"(SELECT a FROM table)['a']"#);
            parse!(r#"(SELECT a FROM table).*"#);
            parse!(r#"(SELECT a FROM table)[*]"#);
        }

        #[test]
        fn function_call() {
            parse!(r#"foo(x, y).a"#);
            parse!(r#"foo(x, y).*"#);
            parse!(r#"foo(x, y)[*]"#);
            parse!(r#"foo(x, y)[5]"#);
            parse!(r#"foo(x, y).a.*"#);
        }

        #[test]
        #[should_panic]
        fn erroneous() {
            parse!(r#"a.b.['item']"#);
            parse!(r#"a.b.{'a': 1, 'b': 2}.a"#);
            parse!(r#"a.b.[1, 2, 3][2]"#);
            parse!(r#"a.b.[*]"#);
        }
    }

    mod sfw {
        use super::*;


/xlink" width="48" height="48" preserveAspectRatio="xMidYMid meet" viewBox="0 0 48 48"><g fill="currentColor"><path d="M11.593 11.026a1.207 1.207 0 00-.742.079 1.384 1.384 0 00-.609.537A1.621 1.621 0 0010 12.5c0 .31.087.61.242.858.156.248.37.432.609.537.237.105.494.131.742.079.248-.053.485-.185.677-.39a1 1 0 011.46 1.368 3.3 3.3 0 01-1.722.978 3.208 3.208 0 01-1.966-.206 3.383 3.383 0 01-1.495-1.304A3.62 3.62 0 018 12.5c0-.678.188-1.346.547-1.92a3.383 3.383 0 011.495-1.304 3.207 3.207 0 011.966-.206c.661.14 1.259.485 1.722.978a1 1 0 11-1.46 1.368 1.302 1.302 0 00-.677-.39ZM38 22a2 2 0 110 4 2 2 0 010-4Zm-7 2a1.5 1.5 0 103 0 1.5 1.5 0 00-3 0Z"/><path fill-rule="evenodd" d="M8 24a3 3 0 003 3h15a3 3 0 100-6H11a3 3 0 00-3 3Zm14-1H11a1 1 0 100 2h11v-2Zm5 1a1 1 0 00-1-1h-2v2h2a1 1 0 001-1Z" clip-rule="evenodd"/><path fill-rule="evenodd" d="M4 24a7 7 0 007 7h26a7 7 0 100-14H11a7 7 0 00-7 7Zm33-5H11a5 5 0 000 10h26a5 5 0 000-10ZM14 32a1 1 0 00-1 1v5a1 1 0 102 0v-1h1.5a2.5 2.5 0 000-5H14Zm3 2.5a.5.5 0 01-.5.5H15v-1h1.5a.5.5 0 01.5.5ZM27 10a1 1 0 011-1h2.5a2.5 2.5 0 010 5H29v1a1 1 0 11-2 0v-5Zm4 1.5a.5.5 0 00-.5-.5H29v1h1.5a.5.5 0 00.5-.5Z" clip-rule="evenodd"/><path d="M23.436 38.351a1 1 0 01-1.872 0l-1.5-4a1 1 0 111.872-.702l.564 1.503.564-1.503a1 1 0 111.872.702l-1.5 4ZM36 15a1 1 0 11-2 0v-2a1 1 0 110-2c0-.327.09-.794.389-1.21.335-.465.885-.79 1.611-.79a1 1 0 010 2 1 1 0 010 2v2Z"/></g></svg>';
  static const String rdt_result_pf_invalid_rectangular =
      '<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="48" height="48" preserveAspectRatio="xMidYMid meet" viewBox="0 0 48 48"><g fill="currentColor"><path d="M10.85 11.105c.238-.105.495-.131.743-.079.248.053.485.185.677.39a1 1 0 001.46-1.368 3.301 3.301 0 00-1.722-.978 3.207 3.207 0 00-1.966.206 3.383 3.383 0 00


pectrum::Spectrum;
use na::{Norm, Dot, zero, Inverse};

const BETA_R: Spectrum = Spectrum {
    r: 5.5e-6,
    g: 13e-6,
    b: 22.4e-6,
};
const BETA_M: Spectrum = Spectrum {
    r: 21e-6,
    g: 21e-6,
    b: 21e-6,
};

pub struct Atmosphere {
    hr: f32,
    hm: f32,
    radius_earth: f32,
    sun_direction: Vector,
    sun_intensity: f32,
    g: f32,
    atmosphere: Sphere,
    transform_inv: Transform,
}

impl Atmosphere {
    pub fn earth(sd: Vector) -> Atmosphere {
        Atmosphere {
            hr: 7994.0,
            hm: 1200.0,
            radius_earth: 6360e3,
            sun_direction: sd,
            sun_intensity: 20.0,
            g: 0.76,
            atmosphere: Sphere::new(6420e3),
            transform_inv: Transform::new(Vector::new(0.0, -6360e3, 0.0), zero(), 1.0)
                .inverse()
                .unwrap(),
        }
    }

    pub fn compute_incident_light(&self, ray: &mut Ray) -> Spectrum {
        let mut r = self.transform_inv * *ray;
        match self.atmosphere.intersect_sphere(&r) {
            None => Spectrum::black(),
            Some((t0, t1)) => {
                if t1 < 0.0 {
                    return Spectrum::black();
                }
                if t0 > r.t_min && t0 > 0.0 {
                    r.t_min = t0;
                }
                if t1 < r.t_max {
                    r.t_max = t1;
                }

                let num_samples = 16u8;
                let num_samples_light = 8u8;

                let segment_length = (r.t_max - r.t_min) / num_samples as f32;
                let mut t_current = r.t_min;
                let mut sum_r = Spectrum::black();
                let mut sum_m = Spectrum::black();
                let mut optical_depth_r = 0.0;
                let mut optical_depth_m = 0.0;
                let mu = r.d.normalize().dot(&self.sun_direction);
                let phase_r = 3.0 / (16.0 * PI) * (1.0 + mu * mu);
                let phase_m = 3.0 / (8.0 * PI) * ((1.0 - self.g * self.g) * (1.0 + mu * mu)) /
                              ((2.0 + self.g * self.g) *
                               (1.0 + self.g * self.g - 2.0 * self.g * mu).powf(1.5));

                for _ in 0..num_samples {
                    let sample_position = r.at(t_current + 0.5 * segment_length);
                    let height = sample_position.to_vector().norm() - self.radius_earth;
                    // compute optical depth for light
                    let h_r = (-height / self.hr).exp() * segment_length;
                    let h_m = (-height / self.hm).exp() * segment_length;
                    optical_depth_r += h_r;
                    optical_depth_m += h_m;
                    // light optical depth
                    let light_ray = Ray::new(sample_position, self.sun_direction);
                    let res = self.atmosphere.intersect_sphere(&light_ray);
                    if res.is_none() {
                        break;
                    }

                    let (_, tl1) = res.unwrap();
                    let segment_length_light = tl1 / num_samples_light as f32;
                    let mut t_


/* Head list classes */

.headlistwrapper {
	width: 100%;
}

.selected {
	border: 1px solid #0A246A;
	background-color: #B6BDD2;
}

.toolbar {
	width: 100%;
}

#headlist {
	width: 100%;
	margin-top: 3px;
	font-size: 11px;
}

#info, #title_element, #meta_element, #script_element, #style_element, #base_element, #link_element, #comment_element, #unknown_element {
	display: none;
}

#addmenu {
	position: absolute;
	border: 1px solid gray;
	display: none;
	z-index: 100;
	background-color: white;
}

#addmenu a {
	display: block;
	width: 100%;
	line-height: 20px;
	text-decoration: none;
	background-color: white;
}

#addmenu a:hover {
	background-color: #B6BDD2;
	color: black;
}

#addmenu span {
	padding-left: 10px;
	padding-right: 10px;
}

#updateElementPanel {
	display: none;
}

#script_element .panel_wrapper div.current {
	height: 108px;
}

#style_element .panel_wrapper div.current {
	height: 108px;
}

#link_element  .panel_wrapper div.current {
	height: 140px;
}

#element_script_value {
	width: 100%;
	height: 100px;
}

#element_comment_value {
	width: 100%;
	height: 120px;
}

#element_style_value {
	width: 100%;
	height: 100px;
}

#element_title, #element_script_src, #element_meta_name, #element_meta_content, #element_base_href, #element_link_href, #element_link_title {
	width: 250px;
}

.updateElementButton {
	margin-top: 3px;
}

/* MSIE specific styles */

* html .addbutton, * html .removebutton, * html .moveupbutton, * html .movedownbutton {
	width: 22px;
	height: 22px;
}

textarea {
	height: 55px;
}

.panel_wrapper div.current {height:420px;}/* Reset */
.defaultSkin table, .defaultSkin tbody, .defaultSkin a, .defaultSkin img, .defaultSkin tr, .defaultSkin div, .defaultSkin td, .defaultSkin iframe, .defaultSkin span, .defaultSkin *, .defaultSkin .mceText {border:0; margin:0; padding:0; background:transparent; white-space:nowrap; text-decoration:none; font-weight:normal; cursor:default; color:#000; vertical-align:baseline; width:auto; border-collapse:separate; text-align:left}
.defaultSkin a:hover, .defaultSkin a:link, .defaultSkin a:visited, .defaultSkin a:active {text-decoration:none; font-weight:normal; cursor:default; color:#000}
.defaultSkin table td {vertical-align:middle}

/* Containers */
.defaultSkin table {direction:ltr;background:transparent}
.defaultSkin iframe {display:block;}
.defaultSkin .mceToolbar {height:26px}
.defaultSkin .mceLeft {text-align:left}
.defaultSkin .mceRight {text-align:right}

/* External */
.defaultSkin .mceExternalToolbar {position:absolute; border:1px solid #CCC; border-bottom:0; display:none;}
.defaultSkin .mceExternalToolbar td.mceToolbar {padding-right:13px;}
.defaultSkin .mceExternalClose {position:absolute; top:3px; right:


        shortname: ":red_circle:",
        code_decimal: "🔴",
        category: "s",
        emoji_order: "2179",
      },
      {
        name: "large_blue_circle",
        unicode: "1f535",
        shortname: ":blue_circle:",
        code_decimal: "🔵",
        category: "s",
        emoji_order: "2180",
      },
    ],
  },
];
// Flash Player Version Detection - Rev 1.6
// Detect Client Browser type
// Copyright(c) 2005-2006 Adobe Macromedia Software, LLC. All rights reserved.
var isIE  = (navigator.appVersion.indexOf("MSIE") != -1) ? true : false;
var isWin = (navigator.appVersion.toLowerCase().indexOf("win") != -1) ? true : false;
var isOpera = (navigator.userAgent.indexOf("Opera") != -1) ? true : false;

function ControlVersion()
{
	var version;
	var axo;
	var e;

	// NOTE : new ActiveXObject(strFoo) throws an exception if strFoo isn't in the registry

	try {
		// version will be set for 7.X or greater players
		axo = new ActiveXObject("ShockwaveFlash.ShockwaveFlash.7");
		version = axo.GetVariable("$version");
	} catch (e) {
	}

	if (!version)
	{
		try {
			// version will be set for 6.X players only
			axo = new ActiveXObject("ShockwaveFlash.ShockwaveFlash.6");

			// installed player is some revision of 6.0
			// GetVariable("$version") crashes for versions 6.0.22 through 6.0.29,
			// so we have to be careful.

			// default to the first public version
			version = "WIN 6,0,21,0";

			// throws if AllowScripAccess does not exist (introduced in 6.0r47)
			axo.AllowScriptAccess = "always";

			// safe to call for 6.0r47 or greater
			version = axo.GetVariable("$version");

		} catch (e) {
		}
	}

	if (!version)
	{
		try {
			// version will be set for 4.X or 5.X player
			axo = new ActiveXObject("ShockwaveFlash.ShockwaveFlash.3");
			version = axo.GetVariable("$version");
		} catch (e) {
		}
	}

	if (!version)
	{
		try {
			// version will be set for 3.X player
			axo = new ActiveXObject("ShockwaveFlash.ShockwaveFlash.3");
			version = "WIN 3,0,18,0";
		} catch (e) {
		}
	}

	if (!version)
	{
		try {
			// version will be set for 2.X player
			axo = new ActiveXObject("ShockwaveFlash.ShockwaveFlash");
			version = "WIN 2,0,0,11";
		} catch (e) {
			version = -1;
		}
	}

	return version;
}

// JavaScript helper required to detect Flash Player PlugIn version information
function GetSwfVer(){
	// NS/Opera version >= 3 check for Flash plugin in plugin array
	var flashVer = -1;

	if (navigator.plugins != null && navigator.plugins.length > 0) {
		if (navigator.plugins["Shockwave Flash 2.0"] || navigator.plugins["Shockwave Flash"]) {
			var swVer2 = navigator.plugins["Shockwave Flash 2.0"] ? " 2.0" : "";
			var flashDescription = navigator.plugins["Shockwave Flash" + swVer2].description;
			var descArray = flashDescription.split(" ");
			var tempArrayMajor = descArray[2].split(".");
			var versionMajor = tempArrayMajor[0];
			var versionMinor = tempArrayMajor[1];
			var versionRevision = descArray[3];


ume(int c) {
    static int i;
    for(i = DL[c].down; i != c; i = DL[i].down) {
        DL[DL[i].right].left = i;
        DL[DL[i].left].right = i;
        s[DL[i].ch]++;
    }
}
int used[MAXC] = {};
int H() {
    static int c, ret, i, j, time = 0;
    for(c = DL[head].right, ++time, ret = 0; c != head; c = DL[c].right) {
        if(used[c] != time) {
            ret ++, used[c] = time;
            for(i = DL[c].down; i != c; i = DL[i].down)
                for(j = DL[i].right; j != i; j = DL[j].right)
                    used[DL[j].ch] = time;
        }
    }
    return ret;
}
void DFS(int k) {
    if(k + H() >= Ans)    return;
    if(DL[head].right == head) {
    	if (k < Ans) {
			Ans = k;
			for (int i = 0; i < k; i++)
				sol[i] = DL[o[i]].data;
		}
        return ;
    }
    int t = MAXV, c, i, j;
    for(i = DL[head].right; i != head; i = DL[i].right) {
        if(s[i] < t) {
            t = s[i], c = i;
        }
    }
    for(i = DL[c].down; i != c; i = DL[i].down) {
        o[k] = i;
        Remove(i);
        for(j = DL[i].right; j != i; j = DL[j].right)	Remove(j);
        DFS(k+1);
        for(j = DL[i].left; j != i; j = DL[j].left)     Resume(j);
        Resume(i);
    }
}
int new_node(int up, int down, int left, int right) {
    assert(size < MAXE);
    DL[size].up = up, DL[size].down = down;
    DL[size].left = left, DL[size].right = right;
    DL[up].down = DL[down].up = DL[left].right = DL[right].left = size;
    assert(size < MAXE);
    return size++;
}
void addrow(int n, int Row[], int data) {
    int a, r, row = -1, k;
    for(a = 0; a < n; a++) {
        r = Row[a];
        DL[size].ch = r, s[r]++;
        DL[size].data = data;
        if(row == -1) {
            row = new_node(DL[DL[r].ch].up, DL[r].ch, size, size);
            DL[row].rh = a;
        }else {
            k = new_node(DL[DL[r].ch].up, DL[r].ch, DL[row].left, row);
            DL[k].rh = a;
        }
    }
}
void init(int m) {
    size = 0;
    head = new_node(0, 0, 0, 0);
    int i;
    for(i = 1; i <= m; i++) {
        new_node(i, i, DL[head].left, head);
        DL[i].ch = i, s[i] = 0;
    }
}
char g[1024][1024];
int ig[1024][1024];
int C[800*800][4];
int main() {
    int n, m;
    while (scanf("%d %d", &


 Debug, PartialEq)]
#[cfg_attr(feature = "serialize", derive(Serialize, Deserialize))]
pub enum HorizontalTextJustification {
    Left = 0,
    Center = 1,
    Right = 2,
    Aligned = 3,
    Middle = 4,
    Fit = 5,
}
}

enum_from_primitive! {
#[derive(Clone, Copy, Debug, PartialEq)]
#[cfg_attr(feature = "serialize", derive(Serialize, Deserialize))]
pub enum ImageClippingBoundaryType {
    Rectangular = 1,
    Polygonal = 2,
}
}

enum_from_primitive! {
#[derive(Clone, Copy, Debug, PartialEq)]
#[cfg_attr(feature = "serialize", derive(Serialize, Deserialize))]
pub enum ImageResolutionUnits
{
    NoUnits = 0,
    Centimeters = 2,
    Inches = 5,
}
}

enum_from_primitive! {
#[derive(Clone, Copy, Debug, PartialEq)]
#[cfg_attr(feature = "serialize", derive(Serialize, Deserialize))]
pub enum JoinStyle {
    None = 0,
    Round = 1,
    Angle = 2,
    Flat = 3,
}
}

enum_from_primitive! {
#[derive(Clone, Copy, Debug, PartialEq)]
#[cfg_attr(feature = "serialize", derive(Serialize, Deserialize))]
pub enum Justification {
    Top = 0,
    Middle = 1,
    Bottom = 2,
}
}

enum_from_primitive! {
#[derive(Clone, Copy, Debug, PartialEq)]
#[cfg_attr(feature = "serialize", derive(Serialize, Deserialize))]
pub enum LayerAndSpatialIndexSaveMode {
    None = 0,
    LayerIndex = 1,
    SpatialIndex = 2,
    LayerAndSpatialIndex = 3,
}
}

enum_from_primitive! {
#[derive(Clone, Copy, Debug, PartialEq)]
#[cfg_attr(feature = "serialize", derive(Serialize, Deserialize))]
pub enum LeaderCreationAnnotationType {
    WithTextAnnotation = 0,
    WithToleranceAnnotation = 1,
    WithBlockReferenceAnnotation = 2,
    NoAnnotation = 3,
}
}

enum_from_primitive! {
#[derive(Clone, Copy, Debug, PartialEq)]
#[cfg_attr(feature = "serialize", derive(Serialize, Deserialize))]
pub enum LeaderHooklineDirection {
    OppositeFromHorizontalVector = 0,
    SameAsHorizontalVector = 1,
}
}

enum_from_primitive! {
#[derive(Clone, Copy, Debug, PartialEq)]
#[cfg_attr(feature = "serialize", derive(Serialize, Deserialize))]
pub enum LeaderPathType {
    StraightLineSegments = 0,
    Spline = 1,
}
}

enum_from_primitive! {
#[derive(Clone, Copy, Debug, PartialEq)]
#[cfg_attr(feature = "serialize", derive(Serialize, Deserialize))]
pub enum LightAttenuationType {
    None = 0,
    InverseLinear = 1,
    InverseSquare = 2,
}
}

enum_from_primitive! {
#[derive(Clone, Copy, Debug, PartialEq)]
#[cfg_attr(feature = "serialize", derive(Serialize, Deserialize))]
pub enum LightType {
    Distant = 1,
    Point = 2,
    Spot = 3,
}
}

enum_from_primitive! {
#[derive(Clone, Copy, Debug, PartialEq)]
#[cfg_attr(feature = "serialize", derive(Serialize, Deserialize))]
pub enum LineTypeStyle {
    Off = 0,
    Solid = 1,
    Dashed = 2,
    Dotted = 3,
    ShortDash = 4,
    MediumDash = 5,
    LongDash


aee}"),
                    ("oang;", "\u{27ed}"),
                    ("oarr;", "\u{21fe}"),
                    ("obrk;", "\u{27e7}"),
                    ("opar;", "\u{2986}"),
                    ("rarr;", "\u{21c9}"),
                    ("squo;", "\u{2019}"),
                    ("trie;", "\u{22b5}"),
                    ("trif;", "\u{25b8}"),
                    ("Arr;", "\u{21d2}"),
                    ("Har;", "\u{2964}"),
                    ("ace;", "\u{223d}\u{331}"),
                    ("ang;", "\u{27e9}"),
                    ("aquo", "\u{bb}"),
                    ("arr;", "\u{2192}"),
                    ("cub;", "\u{7d}"),
                    ("dca;", "\u{2937}"),
                    ("dsh;", "\u{21b3}"),
                    ("eal;", "\u{211c}"),
                    ("ect;", "\u{25ad}"),
                    ("hov;", "\u{3f1}"),
                    ("ing;", "\u{2da}"),
                    ("opf;", "\u{1d563}"),
                    ("par;", "\u{29}"),
                    ("scr;", "\u{1d4c7}"),
                    ("sqb;", "\u{5d}"),
                    ("tri;", "\u{25b9}"),
                    ("cy;", "\u{440}"),
                    ("eg;", "\u{ae}"),
                    ("fr;", "\u{1d52f}"),
                    ("ho;", "\u{3c1}"),
                    ("lm;", "\u{200f}"),
                    ("sh;", "\u{21b1}"),
                    ("eg", "\u{ae}"),
                    ("x;", "\u{211e}"),
                ] {
                    if try_read(other_chars)? {
                        return Ok(Some(CharRef {
                            name: other_chars,
                            characters,
                        }));
                    }
                }

                Ok(None)
            }

            branch_r(try_read)
        }

        's' => {
            #[allow(non_snake_case)]
            fn branch_s<E>(
                mut try_read: impl FnMut(&str) -> Result<bool, E>,
            ) -> Result<Option<CharRef>, E> {
                for (other_chars, characters) in &[
                    ("traightepsilon;", "\u{3f5}"),
                    ("hortparallel;", "\u{2225}"),
                    ("mallsetminus;", "\u{2216}"),
                    ("traightphi;", "\u{3d5}"),
                    ("ucccurlyeq;", "\u{227d}"),
                    ("uccnapprox;", "\u{2aba}"),
                    ("qsubseteq;", "\u{2291}"),
                    ("qsupseteq;", "\u{2292}"),
                    ("ubsetneqq;", "\u{2acb}"),
                    ("uccapprox;", "\u{2ab8}"),
                    ("upsetneqq;", "\u{2acc}"),
                    ("padesuit;", "\u{2660}"),
                    ("ubseteqq;", "\u{2ac5}"),
                    ("ubsetneq;", "\u{228a}"),
                    ("upseteqq;", "\u{2ac6}"),
                    ("upsetneq;", "\u{228b}"),
                    ("cpolint;", "\u{2a13}"),
                    ("etminus;", "\u{2216}"),
                    ("hortmid;", "\u{2223}"),
                    ("meparsl;", "\u{29e4}"),
                    ("qsubset;", "\u{228f}"),
                    ("qsupset;", "\u{2290}"),


and if it fails it
-- 	will try to use "7x13" and then "font,with,commas" instead.
--
-- 	If none of the fonts can be loaded, Vim will keep the current setting.
-- 	If an empty font list is given, Vim will try using other resource
-- 	settings (for X, it will use the Vim.font resource), and finally it
-- 	will try some builtin default which should always be there ("7x13" in
-- 	the case of X).  The font names given should be "normal" fonts.  Vim
-- 	will try to find the related bold and italic fonts.
--
-- 	For Win32 and Mac OS: >
-- 	    :set guifont=*
-- <	will bring up a font requester, where you can pick the font you want.
--
-- 	The font name depends on the GUI used.
--
-- 	For Mac OSX you can use something like this: >
-- 	    :set guifont=Monaco:h10
-- <
-- 	Note that the fonts must be mono-spaced (all characters have the same
-- 	width).
--
-- 	To preview a font on X11, you might be able to use the "xfontsel"
-- 	program.  The "xlsfonts" program gives a list of all available fonts.
--
-- 	For the Win32 GUI
-- 	- takes these options in the font name:
-- 		hXX - height is XX (points, can be floating-point)
-- 		wXX - width is XX (points, can be floating-point)
-- 		b   - bold
-- 		i   - italic
-- 		u   - underline
-- 		s   - strikeout
-- 		cXX - character set XX.  Valid charsets are: ANSI, ARABIC,
-- 		      BALTIC, CHINESEBIG5, DEFAULT, EASTEUROPE, GB2312, GREEK,
-- 		      HANGEUL, HEBREW, JOHAB, MAC, OEM, RUSSIAN, SHIFTJIS,
-- 		      SYMBOL, THAI, TURKISH, VIETNAMESE ANSI and BALTIC.
-- 		      Normally you would use "cDEFAULT".
--
-- 	  Use a `':'`  to separate the options.
-- 	- A `'_'`  can be used in the place of a space, so you don't need to use
-- 	  backslashes to escape the spaces.
-- 	- Examples: >
-- 	    :set guifont=courier_new:h12:w5:b:cRUSSIAN
-- 	    :set guifont=Andale_Mono:h7.5:w4.5
-- <
--- @class vim.opt.guifont: vim.Option,string[]
--- @operator add: vim.opt.guifont
--- @operator sub: vim.opt.guifont
--- @operator pow: vim.opt.guifont
vim.opt.guifont = ""
vim.opt.gfn = vim.opt.guifont
--- @return string[]
function vim.opt.guifont:get()end

-- `'guifontwide'`  `'gfw'` 	string	(default "")
-- 			global
-- 	Comma-separated list of fonts to be used for double-width characters.
-- 	The first font that can be loaded is used.
-- 	Note: The size of these fonts must be exactly twice as wide as the one
-- 	specified with `'guifont'`  and the same height.
--
-- 	When `'guifont'`  has a valid font and `'guifontwide'`  is empty Vim will
-- 	attempt to set `'guifontwide'`  to a matching double-width font.
--- @class vim.opt.guifontwide: vim.Option,string[]
--- @operator add: vim.opt.guifontwide
--- @operator sub: vim.opt.guifontwide
--- @operator pow: vim.opt.guifontwide
vim.opt.guifontwide = ""
vim.opt.gfw = vim.opt.guifontwide
--- @return string[]
functio


<tt>boolean</tt>

<tt>-</tt>

Force to skip all executions of this plugin.
Default value is: <tt>false</tt>.
User property is: <tt>scalor.skip</tt>.

<tt><skipLogReason></tt>

<tt>boolean</tt>

<tt>-</tt>

Enable logging of reason for skipping an execution.
Default value is: <tt>true</tt>.
User property is: <tt>scalor.skipLogReason</tt>.

<tt><skipPackagingList></tt>

<tt>String[]</tt>

<tt>-</tt>

List of packaging types, which are skipped by this plugin.
Default value is: <tt>pom</tt>.
User property is: <tt>scalor.skipPackagingList</tt>.

<tt><skipRegister></tt>

<tt>boolean</tt>

<tt>-</tt>

Flag to skip goal execution: <tt>register-*</tt>.
Default value is: <tt>false</tt>.
User property is: <tt>scalor.skipRegister</tt>.

<tt><skipRegisterMain></tt>

<tt>boolean</tt>

<tt>-</tt>

Flag to skip goal execution: <tt>register-main</tt>.
Default value is: <tt>false</tt>.
User property is: <tt>scalor.skipRegisterMain</tt>.

Parameter Details

<buildEnsureFolders>

Create build source root and target root folders when missing.

Type: <tt>boolean</tt>

Required: <tt>No</tt>

User Property: <tt>scalor.buildEnsureFolders</tt>

Default: <tt>true</tt>

<buildMainResourceFolders>

Resource root folders to be included in compilation scope=main.
Normally uses <tt>src/main/resources</tt>. Absolute path.
Component reference: <a class="externalLi


H, X1
	CALL p256MulInternal<>(SB)
	VOR  T0, T0, U1L
	VOR  T1, T1, U1H

	// X=R ; Y=R ; MUL; T-   // X3 = R*R
	VOR RL, RL, X0

	// VOR  RH, RH, X1
	VOR RL, RL, Y0

	// RH was saved above using STXVD2X
	LXVD2X (R1)(R17), X1_
	VOR    X1, X1, Y1

	// VOR  RH, RH, Y1
	CALL p256MulInternal<>(SB)

	// SUB(T<T-T2)           // X3 = X3-T2
	p256SubInternal(T1,T0,T1,T0,T2H,T2L)

	// ADD(X<U1+U1)          // T1 = 2*U1
	p256AddInternal(X1,X0,U1H,U1L,U1H,U1L)

	// SUB(T<T-X) X3:=T      // X3 = X3-T1 << store-out X3 result reg
	p256SubInternal(T1,T0,T1,T0,X1,X0)
	MOVD    res+0(FP), P3ptr
	LXVD2X  (R8)(R0), SWAP_
	VPERM   T1, T1, SWAP, TT1
	VPERM   T0, T0, SWAP, TT0
	STXVD2X TT0_, (R0)(P3ptr)
	STXVD2X TT1_, (R16)(P3ptr)

	// SUB(Y<U1-T)           // Y3 = U1-X3
	p256SubInternal(Y1,Y0,U1H,U1L,T1,T0)

	// X=R ; Y-  ; MUL; U1=T // Y3 = R*Y3
	VOR RL, RL, X0

	// VOR  RH, RH, X1
	LXVD2X (R1)(R17), X1_
	CALL   p256MulInternal<>(SB)
	VOR    T0, T0, U1L
	VOR    T1, T1, U1H

	// X=S1; Y=T2; MUL; T-   // T2 = S1*T2
	VOR  S1L, S1L, X0
	VOR  S1H, S1H, X1
	VOR  T2L, T2L, Y0
	VOR  T2H, T2H, Y1
	CALL p256MulInternal<>(SB)

	// SUB(T<U1-T); Y3:=T    // Y3 = Y3-T2 << store-out Y3 result reg
	p256SubInternal(T1,T0,U1H,U1L,T1,T0)
	MOVD    res+0(FP), P3ptr
	LXVD2X  (R8)(R0), SWAP_
	VPERM   T1, T1, SWAP, TT1
	VPERM   T0, T0, SWAP, TT0
	STXVD2X TT0_, (R17)(P3ptr)
	STXVD2X TT1_, (R18)(P3ptr)

	RET


 { a: 1 } };

    const ans = deepAssign<Record<string, any>>(object1, object2, object3);

    expect(ans).toEqual({ a: { a: 1, b: 0, c: 2 }, b: { a: 1 } });
  });
});
import { getMetadataStorage } from "@/metadata/getMetadataStorage";
import { type ClassType } from "@/typings";
import { type ClassTypeResolver } from "./types";

export function Resolver(): ClassDecorator;
export function Resolver(typeFunc: ClassTypeResolver): ClassDecorator;
export function Resolver(objectType: ClassType): ClassDecorator;
export function Resolver(objectTypeOrTypeFunc?: Function): ClassDecorator {
  return target => {
    // eslint-disable-next-line no-nested-ternary
    const getObjectType = objectTypeOrTypeFunc
      ? objectTypeOrTypeFunc.prototype
        ? () => objectTypeOrTypeFunc as ClassType
        : (objectTypeOrTypeFunc as ClassTypeResolver)
      : () => {
          throw new Error(
            `No provided object type in '@Resolver' decorator for class '${target.name}!'`,
          );
        };
    getMetadataStorage().collectResolverClassMetadata({
      target,
      getObjectType,
    });
  };
}
import memoizedFetch, { getCachedMemos, isSupportedMemoType, makeMemoizedFetch, memosMatch } from '../index';

const wait = () => new Promise(resolve => setTimeout(resolve, 25));

describe('isSupportedMemoType', () => {
  it('correctly checks type support', () => {
    expect(isSupportedMemoType(1)).toBeTruthy();
    expect(isSupportedMemoType(-1)).toBeTruthy();
    expect(isSupportedMemoType(0)).toBeTruthy();
    expect(isSupportedMemoType(-0)).toBeTruthy();
    expect(isSupportedMemoType('string')).toBeTruthy();
    expect(isSupportedMemoType(true)).toBeTruthy();
    expect(isSupportedMemoType(false)).toBeTruthy();
    expect(isSupportedMemoType({})).toBeFalsy();
    expect(isSupportedMemoType([])).toBeFalsy();
    expect(isSupportedMemoType((): any => null)).toBeFalsy();
  });
});

describe('memosMatch', () => {
  it('matches correctly', () => {
    expect(memosMatch(undefined, undefined)).toBeTruthy();
    expect(memosMatch(undefined, 1)).toBeFalsy();
    expect(memosMatch(1, 1)).toBeTruthy();
    expect(memosMatch(1, [1])).toBeTruthy();
    expect(memosMatch(1, [1, 2])).toBeFalsy();
    expect(() => memosMatch({ some: 'object' }, { some: 'object' })).toThrow();
    const someObject = { some: 'object' };
    expect(() => memosMatch(someObject, someObject)).toThrow();
    expect(() => memosMatch(someObject, { ...someObject })).toThrow();
    expect(() => memosMatch([[]], [[]])).toThrow();
    const emptyArray: any[] = [];
    expect(() => memosMatch([emptyArray], [emptyArray])).toBeTruthy();
  });
});

describe('memoizedFetch', () => {
  it('can fetch normally', async () => {
    const response = await memoizedFetch('myurl', {});
    expect(response.input).toEqual('myurl');
    expect(response.init).toEqual({});
  });

  it('memoizes fetch', async () => {
    const response = await memoizedFetch('myurl', {});
    const response2


 be null if for example webpage is not found on startup
    if (!frame_ || getOnProgressChange().empty()) {
        return;
    }
    std::stringstream script;
    script << getOnProgressChange() << "(" << progress << ");";
    frame_->ExecuteJavaScript(script.str(), frame_->GetURL(), 0);
}

void ProgressBarObserverCEF::progressBarVisibilityChanged(bool visible) {
    // Frame might be null if for example webpage is not found on startup
    if (!frame_ || getOnProgressVisibleChange().empty()) {
        return;
    }
    std::stringstream script;
    script << getOnProgressVisibleChange() << "(" << (visible ? "true" : "false") << ");";
    frame_->ExecuteJavaScript(script.str(), frame_->GetURL(), 0);
}

void ProgressBarObserverCEF::setFrame(CefRefPtr<CefFrame> frame) { frame_ = frame; }

}  // namespace inviwo
/*********************************************************************************
 *
 * Inviwo - Interactive Visualization Workshop
 *
 * Copyright (c) 2023-2025 Inviwo Foundation
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice, this
 * list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *********************************************************************************/

#include <inviwo/ffmpeg/wrap/codecid.h>

#include <inviwo/core/io/serialization/serializer.h>
#include <inviwo/core/io/serialization/deserializer.h>

extern "C" {
#include <libavcodec/avcodec.h>
#include <libavcodec/codec_id.h>
}

namespace inviwo::ffmpeg {

CodecID::CodecID() : id{AV_CODEC_ID_NONE} {}
CodecID::CodecID(AVCodecID id) : id{id} {}

std::string_view CodecID::name() const { return avcodec_get_name(id); }
std::optional<std::string_view> CodecID::longName() const {
    auto desc = avcodec_descriptor_get(id);
    if (desc && desc->long_name) {
        return desc->long_name;
    } else {
        return std::nullopt;
    }
}
std::string_view CodecID::typeString() const {
    if (auto* chr = av_get_media_type_string(type())) {
        return chr;
    } else {
        return "";
    }
}
std::string CodecID::desc() const { return fmt::format("{}", *this); }

AVMediaType CodecID::type() const { return avcodec_get_type(id); }

CodecID::operator bool() const { return id != AV_CODEC_ID_NONE; }

void CodecID::serialize(Serializer& s) const { s.serialize("codecId", id); }
void CodecID::deserialize(Deserializer& d) { d.deserialize("codecId", id); }

}  // namespace inviwo::ffmpeg
/*********************************************************************************
 *
 * Inviwo - Interactive Visualization Workshop
 *
 * Copyright (c) 2019-2025 Inviwo Foundation
 * All rights reserved.
 *
 * Redistribu


sans-serif, 'Apple Color Emoji',
        'Segoe UI Emoji', 'Segoe UI Symbol';
    font-size: 14px;
    line-height: 1.5;
    color: #24292e;
}

.github-testcase .sticky-file-header {
    position: sticky;
    z-index: 6;
    top: 0px;
}

.github-testcase .file-header {
    height: 60px;
    padding: 5px 10px;
    background-color: #fafbfc;
    border-bottom: 1px solid #e1e4e8;
    border-top-left-radius: 2px;
    border-top-right-radius: 2px;
}

.github-testcase .container {
    width: 980px;
    margin-right: auto;
    margin-left: auto;
}

.github-testcase .file {
    position: relative;
    margin-top: 16px;
    margin-bottom: 16px;
    border: 1px solid #ddd;
    border-radius: 3px;
}

.github-testcase .blob-wrapper {
    overflow-x: auto;
    overflow-y: hidden;
    border-bottom-right-radius: 3px;
    border-bottom-left-radius: 3px;
}

.github-testcase table {
    border-spacing: 0;
    border-collapse: collapse;
    -moz-tab-size: 8;
    tab-size: 8;
}

.github-testcase .blob-code {
    position: relative;
    padding-right: 10px;
    padding-left: 10px;
    line-height: 20px;
    vertical-align: top;
}

.github-testcase .blob-code-inner {
    overflow: visible;
    font-family: 'SFMono-Regular', Consolas, 'Liberation Mono', Menlo, Courier, monospace;
    font-size: 12px;
    color: #24292e;
    word-wrap: normal;
    white-space: pre;
}

.github-testcase .blob-code-inner::before {
    content: '';
}

.github-testcase .blob-num {
    width: 1%;
    min-width: 50px;
    padding-right: 10px;
    padding-left: 10px;
    font-family: 'SFMono-Regular', Consolas, 'Liberation Mono', Menlo, Courier, monospace;
    font-size: 12px;
    line-height: 20px;
    color: rgba(27, 31, 35, 0.3);
    text-align: right;
    white-space: nowrap;
    vertical-align: top;
    cursor: pointer;
    -webkit-user-select: none;
    -moz-user-select: none;
    -ms-user-select: none;
    user-select: none;
}

.github-testcase .blob-num::before {
    content: attr(data-line-number);
}

.github-testcase td {
    padding: 0;
}
// This file is a fork from JetBrainsToggles.module.scss and contains JetBrains specific UI changes

.toggle-container {
    display: flex;
    align-items: center;
    color: var(--jb-icon-color);
}

.separator {
    /* stylelint-disable-next-line declaration-property-unit-allowed-list */
    width: 1px;
    height: 1.125rem;
    margin: 0 0.5rem 0 0.375rem;
    background-color: var(--border-color-2);
}

.copy-query-button {
    padding: 0.125rem;
}

.cancel-button {
    &:not(:disabled) {
        cursor: default;
    }

    font-size: 1rem;
    color: var(--jb-icon-color);
}

.toggle-wrapper {
    &:not(:last-child) {
        margin-right: 0.125rem;
    }
}

.toggle {
    display: flex;
    cursor: default;
    border-radius: 4px;
    border: 2px solid transparent;

    &:


relative' },

        // BEQ
        0xF0: { name: 'BEQ', fn: () => this.brs(flags.Z), mode: 'relative' },

        // BMI
        0x30: { name: 'BMI', fn: () => this.brs(flags.N), mode: 'relative' },

        // BNE
        0xD0: { name: 'BNE', fn: () => this.brc(flags.Z), mode: 'relative' },

        // BPL
        0x10: { name: 'BPL', fn: () => this.brc(flags.N), mode: 'relative' },

        // BVC
        0x50: { name: 'BVC', fn: () => this.brc(flags.V), mode: 'relative' },

        // BVS
        0x70: { name: 'BVS', fn: () => this.brs(flags.V), mode: 'relative' },

        // TAX
        0xAA: { name: 'TAX', fn: () => this.tax(), mode: 'implied' },

        // TXA
        0x8A: { name: 'TXA', fn: () => this.txa(), mode: 'implied' },

        // TAY
        0xA8: { name: 'TAY', fn: () => this.tay(), mode: 'implied' },

        // TYA
        0x98: { name: 'TYA', fn: () => this.tya(), mode: 'implied' },

        // TSX
        0xBA: { name: 'TSX', fn: () => this.tsx(), mode: 'implied' },

        // TXS
        0x9A: { name: 'TXS', fn: () => this.txs(), mode: 'implied' },

        // PHA
        0x48: { name: 'PHA', fn: () => this.pha(), mode: 'implied' },

        // PLA
        0x68: { name: 'PLA', fn: () => this.pla(), mode: 'implied' },

        // PHP
        0x08: { name: 'PHP', fn: () => this.php(), mode: 'implied' },

        // PLP
        0x28: { name: 'PLP', fn: () => this.plp(), mode: 'implied' },

        // JMP
        0x4C: {
            name: 'JMP', fn: () => this.jmp(this.readAddrAbsolute), mode: 'absolute'
        },
        0x6C: {
            name: 'JMP', fn: () => this.jmp(this.readAddrAbsoluteIndirectBug), mode: 'absoluteIndirect'
        },
        // JSR
        0x20: { name: 'JSR', fn: () => this.jsr(), mode: 'absolute' },

        // RTS
        0x60: { name: 'RTS', fn: () => this.rts(), mode: 'implied' },

        // RTI
        0x40: { name: 'RTI', fn: () => this.rti(), mode: 'implied' },

        // SEC
        0x38: { name: 'SEC', fn: () => this.set(flags.C), mode: 'implied' },

        // SED
        0xF8: { name: 'SED', fn: () => this.set(flags.D), mode: 'implied' },

        // SEI
        0x78: { name: 'SEI', fn: () => this.set(flags.I), mode: 'implied' },

        // CLC
        0x18: { name: 'CLC', fn: () => this.clr(flags.C), mode: 'implied' },

        // CLD
        0xD8: { name: 'CLD', fn: () => this.clr(flags.D), mode: 'implied' },

        // CLI
        0x58: { name: 'CLI', fn: () => this.clr(flags.I), mode: 'implied' },

        // CLV
        0xB8: { name: 'CLV', fn: () => this.clr(flags.V), mode: 'implied' },

        // NOP


amespace Content.Server.Power.Components
{
    /// <summary>
    ///     Connects the loading side of a <see cref="BatteryComponent"/> to a non-APC power network.
    /// </summary>
    [RegisterComponent]
    public sealed partial class BatteryChargerComponent : BasePowerNetComponent
    {
        protected override void AddSelfToNet(IPowerNet net)
        {
            net.AddCharger(this);
        }

        protected override void RemoveSelfFromNet(IPowerNet net)
        {
            net.RemoveCharger(this);
        }
    }
}


<Direction, [number, number]> = new Map([
    [Direction.North, [0, -1]],
    [Direction.South, [0, 1]],
    [Direction.West, [1, 0]],
    [Direction.East, [-1, 0]],
]);

export function move(d: Direction, p: [number, number]): [number, number] {
    const adder: [number, number] = OFFSET.get(d);
    const x: number = p[0] + adder[0];
    const y: number = p[1] + adder[1];
    return [x, y];
}

export function adj(p: [number, number]): [number, number][] {
    return ALL_DIR.map(d => move(d, p));
}

export function reverse(d: Direction): Direction {
    switch (d) {
        case Direction.North:
            return Direction.South;
        case Direction.South:
            return Direction.North;
        case Direction.East:
            return Direction.West;
        case Direction.West:
            return Direction.East;
    }
}

export function findDirection(start: [number, number],
    end: [number, number]): Direction {
    let d: Direction = Direction.North;

    const x: number = end[0] - start[0];
    const y: number = end[1] - start[1];
    OFFSET.forEach((v, k) => {
        if (v[0] === x && v[1] === y) {
            d = k;
        }
    });

    return d;
}
import { QLabel } from '../QLabel';
import { QPixmap } from '../../QtGui/QPixmap';
import { QMovie } from '../../QtGui/QMovie';

describe('QLabel', () => {
    const label = new QLabel();
    afterAll(() => {
        label.close();
    });
    it('instantiate a label instance', () => {
        const label = new QLabel();
        expect(label.inherits('QLabel')).toBe(true);
    });
    it('setText', () => {
        const label = new QLabel();
        label.setText('hello');
        expect(label.text()).toEqual('hello');
    });
    it('setWordWrap', () => {
        const label = new QLabel();
        label.setWordWrap(true);
        expect(label.wordWrap()).toEqual(true);
        label.setWordWrap(false);
        expect(label.wordWrap()).toEqual(false);
    });
    it('setPixmap', () => {
        const label = new QLabel();
        const pixMap = new QPixmap();
        label.setPixmap(pixMap);
        expect(label.pixmap()).toEqual(pixMap);
    });
    it('setMovie', () => {
        const label = new QLabel();
        const movie = new QMovie();
        label.setMovie(movie);
        expect(label.movie()).toEqual(movie);
    });
    it('check if signals are working', () => {
        const widget = new QLabel();
        const mock = jest.fn();
        widget.addEventListener('objectNameChanged', mock);
        widget.setObjectName('testName');
        expect(mock).toBeCalledWith('testName');
        expect(mock).toBeCalledTimes(1);
    });
    it('check if signals are working from QWidget', () => {
        const widget = new QLabel();
        const mock = jest.fn();
        widget.addEventListener('windowTitleChanged', mock);
        widget.setWindowTitle('testName');
        expect(mock).toBeCalledWith('testName');
        expect(mock).toBeCalledTimes(1);
    });
});
import {AppLanguage} from '../programming-languages


Orig", VcsTag::Orig),
                ("Original", VcsTag::Orig),
                ("Debian", VcsTag::Debian),
                ("Upstream", VcsTag::Upstream),
            ].into_iter()
        {
            // Common form: Debian-Vcs-Git, Orig-Vcs-Browser, Original-Vcs-Bzr, Upstream-Vcs-Bzr
            if let Some(x) = map.remove(format!("{}-Vcs-{}", tag_token, vcs_token).as_str()) {
                found.push(Entry::new(x, vcs, tag));
            }
            // Vcs-Upstream-Bzr seen in the wild
            else if let Some(x) = map.remove(
                format!("Vcs-{}-{}", tag_token, vcs_token).as_str(),
            )
            {
                found.push(Entry::new(x, vcs, tag));
            }
        }
    }

    let mut builder = builder.borrow().init_vcs(as_u32(found.len()));

    for (i, entry) in found.into_iter().enumerate() {
        let mut builder = builder.borrow().get(as_u32(i));
        builder.set_description(&entry.description);
        builder.set_type(entry.vcs);
        builder.set_tag(entry.tag);
    }

    Ok(())
}
/*
cargo test --test e0001 tests::it_works
*/

/*
This error suggests that the expression arm corresponding to the noted pattern will never
be reached as for all possible values of the expression being matched, one of the preceding
patterns will match.
*/
#[cfg(test)]
mod tests {
    #[test]
    //#[should_panic()]
    #[allow(unreachable_patterns)]
    fn with_error() {
        //  #[warn(unreachable_patterns)]
        match Some(0) {
            Some(_bar) => { /* ... */ }
            _x => { /* ... */ } // This handles the `None` case
            _ => { /* ... */ }  // All possible cases have already been handled
        }
    }

    #[test]
    fn without_error() {
        match Some(0) {
            Some(_bar) => { /* ... */ }

            _ => { /* ... */ } // All possible cases have already been handled
        }
    }
}
#![allow(dead_code)]

use std::collections::HashMap;
use std::path::{Path, PathBuf};
use tempfile::NamedTempFile;

use crate::{
    error::{InitializationError, PatchLifeCycleError},
    types::{PatchFileHandle, ReceiverHandle},
};

/// Activates audio in pd.
///
/// # Errors
///
/// A list of errors that can occur:
/// - [`SendError`](crate::error::SendError)
///   - [`MissingDestination`](crate::error::SendError::MissingDestination)
/// - [`SizeError`](crate::error::SizeError)
///   - [`TooLarge`](crate::error::SizeError::TooLarge)
///
/// To match over these errors, you would need to downcast the returned error.
pub fn dsp_on() -> Result<(), Box<dyn std::error::Error>> {
    crate::send::start_message(1)?;
    crate::send::add_float_to_started_message(1.0);
    crate::send::finish_message_as_typed_message_and_send_to("pd", "dsp")?;
    Ok(())
}

/// De-activates audio in pd.
///
/// # Errors
///
/// A list of errors that can occur:
/// - [`SendError`](crate::error::SendError)
///   - [`MissingDestination`](crate::error::SendError::MissingDestination)
/// - [`SizeError`](crate::error::SizeError)
///   - [`TooLarge`](crate::error::SizeError::TooLarge)
///
/// To match over these errors, you would need to downcast the returned error.
pub fn dsp_off() -> Result<(), Box<dyn std::error::Error>> {
    crate::send::start_message(1)?;
    crate::send::add_float_to_started_message(0.0);


nse 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 io.netty.buffer;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.function.Executable;

import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;

public abstract class AbstractPooledByteBufTest extends AbstractByteBufTest {

    protected abstract ByteBuf alloc(int length, int maxCapacity);

    @Override
    protected ByteBuf newBuffer(int length, int maxCapacity) {
        ByteBuf buffer = alloc(length, maxCapacity);

        // Testing if the writerIndex and readerIndex are correct when allocate and also after we reset the mark.
        assertEquals(0, buffer.writerIndex());
        assertEquals(0, buffer.readerIndex());
        buffer.resetReaderIndex();
        buffer.resetWriterIndex();
        assertEquals(0, buffer.writerIndex());
        assertEquals(0, buffer.readerIndex());
        return buffer;
    }

    @Test
    public void ensureWritableWithEnoughSpaceShouldNotThrow() {
        ByteBuf buf = newBuffer(1, 10);
        buf.ensureWritable(3);
        assertThat(buf.writableBytes()).isGreaterThanOrEqualTo(3);
        buf.release();
    }

    @Test
    public void ensureWritableWithNotEnoughSpaceShouldThrow() {
        final ByteBuf buf = newBuffer(1, 10);
        try {
            assertThrows(IndexOutOfBoundsException.class, new Executable() {
                @Override
                public void execute() {
                    buf.ensureWritable(11);
                }
            });
        } finally {
            buf.release();
        }
    }

    @Override
    @Test
    public void testMaxFastWritableBytes() {
        ByteBuf buffer = newBuffer(150, 500).writerIndex(100);
        assertEquals(50, buffer.writableBytes());
        assertEquals(150, buffer.capacity());
        assertEquals(500, buffer.maxCapacity());
        assertEquals(400, buffer.maxWritableBytes());

        int chunkSize = pooledByteBuf(buffer).maxLength;
        assertTrue(chunkSize >= 150);
        int remainingInAlloc = Math.min(chunkSize - 100, 400);
        assertEquals(remainingInAlloc, buffer.maxFastWritableBytes());

        // write up to max, chunk alloc should not change (same handle)
        long handleBefore = pooledByteBuf(buffer).handle;
        buffer.writeBytes(new byte[remainingInAlloc]);
        assertEquals(handleBefore, pooledByteBuf(buffer).handle);

        assertEquals(0, buffer.maxFastWritableBytes());
        // writing one more should trigger a reallocation (new handle)
        buffer.writeByte(7);
        assertNotEquals(handleBefore, pooledByteBuf(buffer).handle);

        // should not exceed maxCapacity even if chunk alloc does
        buffer.capacity(500);
        assertEquals(500 - buffer.writerIndex(), buffer.maxFastWritableBytes());
        buffer.release();
    }

    private static PooledByteBuf<?> pooledByteBuf(ByteBuf buffer) {
        // might need to unwrap if swapped (LE) and/or leak-aware-wrapped
        while (!(buffer instanceof PooledByteBuf)) {
            buffer = buffer.unwrap();
        }


b'I', b'K', b'J',
    b'K', b'K', b'K', b'L', b'K', b'M', b'L', b'0', b'L', b'1', b'L', b'2', b'L', b'3', b'L', b'4',
    b'L', b'5', b'L', b'6', b'L', b'7', b'L', b'8', b'L', b'9', b'L', b'A', b'L', b'B', b'L', b'C',
    b'L', b'D', b'L', b'E', b'L', b'F', b'L', b'G', b'L', b'H', b'L', b'I', b'L', b'J', b'L', b'K',
    b'L', b'L', b'L', b'M', b'M', b'0', b'M', b'1', b'M', b'2', b'M', b'3', b'M', b'4', b'M', b'5',
    b'M', b'6', b'M', b'7', b'M', b'8', b'M', b'9', b'M', b'A', b'M', b'B', b'M', b'C', b'M', b'D',
    b'M', b'E', b'M', b'F', b'M', b'G', b'M', b'H', b'M', b'I', b'M', b'J', b'M', b'K', b'M', b'L',
    b'M', b'M',
];
pub const DIGIT_TO_BASE24_SQUARED: [u8; 1152] = [
    b'0', b'0', b'0', b'1', b'0', b'2', b'0', b'3', b'0', b'4', b'0', b'5', b'0', b'6', b'0', b'7',
    b'0', b'8', b'0', b'9', b'0', b'A', b'0', b'B', b'0', b'C', b'0', b'D', b'0', b'E', b'0', b'F',
    b'0', b'G', b'0', b'H', b'0', b'I', b'0', b'J', b'0', b'K', b'0', b'L', b'0', b'M', b'0', b'N',
    b'1', b'0', b'1', b'1', b'1', b'2', b'1', b'3', b'1', b'4', b'1', b'5', b'1', b'6', b'1', b'7',
    b'1', b'8', b'1', b'9', b'1', b'A', b'1', b'B', b'1', b'C', b'1', b'D', b'1', b'E', b'1', b'F',
    b'1', b'G', b'1', b'H', b'1', b'I', b'1', b'J', b'1', b'K', b'1', b'L', b'1', b'M', b'1', b'N',
    b'2', b'0', b'2', b'1', b'2', b'2', b'2', b'3', b'2', b'4', b'2', b'5', b'2', b'6', b'2', b'7',
    b'2', b'8', b'2', b'9', b'2', b'A', b'2', b'B', b'2', b'C', b'2', b'D', b'2', b'E', b'2', b'F',
    b'2', b'G', b'2', b'H', b'2', b


                name = it.text()
                scanlator =
                    it.attr("abs:href").toHttpUrl().host // show where chapters are actually from
            }
            date_upload = dateFormat.tryParse(element.selectDateFromElement().attr("title"))
        }
    }

    override fun pageListRequest(chapter: SChapter): Request {
        if (chapter.url.startsWith("http")) {
            return GET(chapter.url, headers)
        }
        return super.pageListRequest(chapter)
    }

    private fun extractArray(scriptContent: String, arrayName: String): List<String> {
        val pattern = Pattern.compile("$arrayName\\s*=\\s*\\[([^]]+)]")
        val matcher = pattern.matcher(scriptContent)
        val arrayValues = mutableListOf<String>()

        if (matcher.find()) {
            val arrayContent = matcher.group(1)
            val values = arrayContent?.split(",")
            if (values != null) {
                for (value in values) {
                    arrayValues.add(
                        value.trim()
                            .removeSurrounding("\"")
                            .replace("\\/", "/")
                            .removeSuffix("/"),
                    )
                }
            }
        }

        return arrayValues
    }

    override fun pageListParse(document: Document): List<Page> {
        val content = document.select("script:containsData(cdns =)").joinToString("\n") { it.data() }
        val cdns =
            extractArray(content, "cdns") + extractArray(content, "backupImage")
        val chapterImages = extractArray(content, "chapterImages")

        // Add all parsed cdns to set
        cdnSet.addAll(cdns)

        return chapterImages.mapIndexed { i, imagePath ->
            val parsedUrl = cdns[0].toHttpUrl().run {
                newBuilder()
                    .encodedPath(
                        "/$imagePath".replace(
                            "//",
                            "/",
                        ),
                    ) // replace ensures that there's at least one trailing slash prefix
                    .build()
                    .toString()
            }

            Page(i, document.location(), parsedUrl)
        }.ifEmpty {
            document.select("div.container-chapter-reader > img").mapIndexed { i, img ->
                Page(i, imageUrl = img.absUrl("src"))
            }
        }
    }

    override fun imageRequest(page: Page): Request {
        return GET(page.imageUrl!!, headers).newBuilder()
            .tag(MangaBoxFallBackTag::class.java, MangaBoxFallBackTag()).build()
    }

    override fun imageUrlParse(document: Document): String = throw UnsupportedOperationException()

    // Based on change_alias JS function from Mangakakalot's website
    @SuppressLint("DefaultLocale")
    open fun normalizeSearchQuery(query: String): String {
        var str = query.lowercase()
        str = str.replace("[àáạảãâầấậẩẫăằắặẳẵ]".toRegex(), "a")
        str = str.replace("[èéẹẻẽêềếệểễ]".toRegex(), "e")
        str = str.replace("[ìíịỉĩ]".toRegex(), "i")
        str = str.replace("[òóọỏõôồốộổỗơờớợởỡ]".toRegex(), "o")
        str = str.replace("[ùúụủũưừứựửữ]".toRegex(), "u")
        str = str.replace("[ỳýỵỷỹ]".toRegex(), "y")
        str = str.replace("đ".toRegex(), "d")
        str = str.replace(


fig) {
		c.Overwrite = false
	})
	if err != nil {
		return nil, errors.Wrapf(err, "cannot merge spec.initProvider and spec.forProvider parameters for resource \"%s/%s\"", tr.GetNamespace(), tr.GetName())
	}

	return params, nil
}

// LateInitialize this RecoveryGroup using its observed tfState.
// returns True if there are any spec changes for the resource.
func (tr *RecoveryGroup) LateInitialize(attrs []byte) (bool, error) {
	params := &RecoveryGroupParameters{}
	if err := json.TFParser.Unmarshal(attrs, params); err != nil {
		return false, errors.Wrap(err, "failed to unmarshal Terraform state parameters for late-initialization")
	}
	opts := []resource.GenericLateInitializerOption{resource.WithZeroValueJSONOmitEmptyFilter(resource.CNameWildcard)}

	li := resource.NewGenericLateInitializer(opts...)
	return li.LateInitialize(&tr.Spec.ForProvider, params)
}

// GetTerraformSchemaVersion returns the associated Terraform schema version
func (tr *RecoveryGroup) GetTerraformSchemaVersion() int {
	return 0
}
// SPDX-FileCopyrightText: 2024 The Crossplane Authors <https://crossplane.io>
//
// SPDX-License-Identifier: Apache-2.0

// Code generated by upjet. DO NOT EDIT.

package v1beta1

import (
	ujconversion "github.com/crossplane/upjet/v2/pkg/controller/conversion"
	"github.com/crossplane/upjet/v2/pkg/resource"
	"github.com/pkg/errors"
	"sigs.k8s.io/controller-runtime/pkg/conversion"
)

// ConvertTo converts this ResourceSet to the hub type.
func (tr *ResourceSet) ConvertTo(dstRaw conversion.Hub) error {
	spokeVersion := tr.GetObjectKind().GroupVersionKind().Version
	hubVersion := dstRaw.GetObjectKind().GroupVersionKind().Version
	if err := ujconversion.RoundTrip(dstRaw.(resource.Terraformed), tr); err != nil {
		return errors.Wrapf(err, "cannot convert from the spoke version %q to the hub version %q", spokeVersion, hubVersion)
	}
	return nil
}

// ConvertFrom converts from the hub type to the ResourceSet type.
func (tr *ResourceSet) ConvertFrom(srcRaw conversion.Hub) error {
	spokeVersion := tr.GetObjectKind().GroupVersionKind().Version
	hubVersion := srcRaw.GetObjectKind().GroupVersionKind().Version
	if err := ujconversion.RoundTrip(tr, srcRaw.(resource.Terraformed)); err != nil {
		return errors.Wrapf(err, "cannot convert from the hub version %q to the spoke version %q", hubVersion, spokeVersion)
	}
	return nil
}
// SPDX-FileCopyrightText: 2024 The Crossplane Authors <https://crossplane.io>
//
// SPDX-License-Identifier: Apache-2.0

// Code generated by upjet. DO NOT EDIT.

package v1beta1

import (
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/runtime/schema"

	v1 "github.com/crossplane/crossplane-runtime/v2/apis/common/v1"
)

type RecoveryGroupInitParameters struct {

	// List of cell arns to add as nested fault domains within this recovery group
	Cells []*string `json:"cells,omitempty" tf:"cells,omitempty"`

	// Key-value map of resource tags.
	// +mapType=granular
	Tags map[string]*string `json:"tags,omitempty" tf:"tags,omitempty"`
}

type RecoveryGroupObservation struct {

	// ARN of the recovery group
	Arn *string `json:"arn,omitempty


Hintergrund der Poprevolution arbeiteten findige Plattenfirmen und Manager daran, Hits zu planen, Talente zu entdecken und Trends frühzeitig zu erkennen. Mit der Industrialisierung der Musik entstand eine arbeitsteilige Produktion: Songwriter komponierten Melodien, Produzenten formten den Sound, Choreographen und Stylisten kreierten das Gesamtbild. Stars wie **Madonna** oder der frühere **Michael Jackson** wussten dieses System geschickt zu nutzen. Sie verbanden mitreißende Songs mit spektakulären Shows und mutigen Mode-Statements.

Der internationale Markt wurde immer wichtiger. Lizenzmodelle, Übersetzungen und Coverversionen machten Popmusik zu einem Milliarden-Business. Plötzlich konnte eine Melodie, die in einer Londoner Garage entstand, Millionen Hörer auf der ganzen Welt erreichen. Fernsehsendungen, Werbekampagnen und Großveranstaltungen sorgten für eine massive Verbreitung und sicherten den langfristigen Erfolg von Pop als musikalisches Leitmedium.

### Pop und Wandel: Politische, soziale und technische Einflüsse in bewegten Zeiten

Pop war nie bloß Unterhaltung. In bewegten Zeiten wurde die Musik zur Plattform für gesellschaftliche Auseinandersetzungen. Während des Vietnamkriegs demonstrierten junge Leute mit *Protest-Songs*, in den **1980ern** wurden Themen wie Gleichberechtigung, Umwelt oder Frieden in eingängige Melodien verpackt. Künstler wie **U2** oder **Sting** zeigten: *Pop* kann politisch sein – aber immer transportiert er die Energie seiner Epoche.

Die technischen Entwicklungen setzten sich immer weiter fort. Mit dem Siegeszug von *CDs* und später *digitalen Downloads* aber auch *Streamingdiensten* wie Spotify wurde Popmusik zum ständigen Begleiter des Alltags. Sie prägte Werbespots, Filme und Trends in den sozialen Medien. Der Sound von heute wird nicht mehr nur im Studio kreiert, sondern weltweit in Netzwerken geteilt, bearbeitet und neu interpretiert.

### Vielfalt und Fusion: Pop als Schnittstelle verschiedener Stile

Einer der größten Erfolgsfaktoren des Pop liegt in seiner Offenheit. Die Stilrichtung saugt Einflüsse aus anderen Genres auf, um immer wieder frische Akzente zu setzen. In den **1990ern** verschmolzen Pop und Tanzmusik zu *Eurodance*, während Hip-Hop oder *R&B*-Elemente neue Klangfarben schufen. Künstlerinnen wie **Beyoncé** verbanden Soul, Funk und moderne Clubsounds zu eigenen Welten. Gleichzeitig entstanden unzählige Subgenres – von *Synthpop* bis *Indiepop*.

Die Globalisierung sorgte dafür, dass Popmusik überall zu Hause war. Lateinamerikanische Rhythmen, afrikanische Beats oder asiatische Melodik fanden Eingang in den Mainstream. Damit wurde Popmusik zum Soundtrack einer Welt, in der Herkunft, Sprache und Kulturgrenzen immer mehr verwischen.

### Musik für alle: Die universelle Sprache des Pop

Am Ende steht Popmusik als Spiegel ihrer Zeit. Sie fängt Gefühle, Hoffnungen und Erlebnisse ein, übersetzt sie in Melodien, die überall auf dem Globus verstanden werden. Ob Freude oder Protest, große Partys oder stille Sehnsucht – Pop ist immer mittendrin. Die Geschichte dieses Genres ist eine Geschichte des Aufbruchs, der Innovation und der ständigen Erneuerung. Jeder Song, der zum Ohrwur


Month/serializer/ISO_BASIC", IsoBasicYearMonthSerializer)
        for ((yearMonth, json) in listOf(
            Pair(YearMonth(2020, 12), "\"202012\""),
            Pair(YearMonth(-2020, 1), "\"-202001\""),
            Pair(YearMonth(2019, 10), "\"201910\""),
        )) {
            assertEquals(json, Json.encodeToString(IsoBasicYearMonthSerializer, yearMonth))
            assertEquals(yearMonth, Json.decodeFromString(IsoBasicYearMonthSerializer, json))
        }
    }
}
package kotlinx.coroutines.android

import kotlinx.coroutines.testing.*
import android.os.*
import kotlinx.coroutines.*
import kotlinx.coroutines.testing.*
import org.junit.Test
import org.junit.runner.*
import org.robolectric.*
import org.robolectric.annotation.*
import org.robolectric.shadows.*
import java.util.concurrent.*
import kotlin.test.*

@RunWith(RobolectricTestRunner::class)
@LooperMode(LooperMode.Mode.LEGACY)
@Config(manifest = Config.NONE, sdk = [28])
class HandlerDispatcherTest : MainDispatcherTestBase.WithRealTimeDelay() {
    @Test
    fun testDefaultDelayIsNotDelegatedToMain() = runTest {
        val mainLooper = Shadows.shadowOf(Looper.getMainLooper())
        mainLooper.pause()
        assertFalse { mainLooper.scheduler.areAnyRunnable() }

        val job = launch(Dispatchers.Default, start = CoroutineStart.UNDISPATCHED) {
            expect(1)
            delay(Long.MAX_VALUE)
            expectUnreached()
        }
        expect(2)
        assertEquals(0, mainLooper.scheduler.size())
        job.cancelAndJoin()
        finish(3)
    }

    @Test
    fun testWithTimeoutIsDelegatedToMain() = runTest {
        val mainLooper = Shadows.shadowOf(Looper.getMainLooper())
        mainLooper.pause()
        assertFalse { mainLooper.scheduler.areAnyRunnable() }
        val job = launch(Dispatchers.Main, start = CoroutineStart.UNDISPATCHED) {
            withTimeout(1) {
                expect(1)
                hang { expect(3) }
            }
            expectUnreached()
        }
        expect(2)
        assertEquals(1, mainLooper.scheduler.size())
        // Schedule cancellation
        mainLooper.runToEndOfTasks()
        job.join()
        finish(4)
    }

    @Test
    fun testDelayDelegatedToMain() = runTest {
        val mainLooper = Shadows.shadowOf(Looper.getMainLooper())
        mainLooper.pause()
        val job = launch(Dispatchers.Main, start = CoroutineStart.UNDISPATCHED) {
            expect(1)
            delay(1)
            expect(3)
        }
        expect(2)
        assertEquals(1, mainLooper.scheduler.size())
        // Schedule cancellation
        mainLooper.runToEndOfTasks()
        job.join()
        finish(4)
    }

    @Test
    fun testAwaitFrame() = runTest {
        doTestAwaitFrame()

        reset()

        // Now the second test: we cannot test it separately because we're caching choreographer in HandlerDispatcher
        doTestAwaitWithDetectedChoreographer()
    }

    private fun CoroutineScope.doTestAwaitFrame() {
        ShadowChoreographer.setPostFrameCallbackDelay(100)
        val mainLooper = Shadows.shadowOf(Looper.getMainLooper())
        mainLooper.pause()
        launch(Dispatchers.Main, start = CoroutineStart.UNDISPATCHED) {
            expect(1)
            awaitFrame()
            expect(3)
        }
        expect(2)
        // Run choreographer detection
        mainLooper.runOneTask()
        finish(4)
    }

    private fun CoroutineScope.doTestAwaitWithDetectedChoreographer() {
        Shadow


        coffee_values = [MENU[coffee_name]["ingredients"].get(k, 0) for k in ("water", "milk", "coffee")]
        for i in range(len(machine_values)):
            usage = machine_values[i] - coffee_values[i]
            logging.debug("Update ingredients")
            resources[keys[i]] = usage
        countdown("Preparing coffee",5)
        print("\nYour coffee is ready!☕")
        print("-" * 50)
        coffee_readiness = True
        prep_coffee = False
        logging.debug("Return to the main menu.")
        return prep_coffee, coffee_readiness

    coffee_ready = check_ingredients(choice)
    while not coffee_ready:
        logging.debug("Enough ingredient")
        prepare_the_coffee,coffee_ready = coin_handler(choice)
        while prepare_the_coffee:
            logging.debug("Enough money")
            prepare_the_coffee, coffee_ready= prepare_coffee(choice)

while True:
    print(f"""☕Coffee machine!☕
    {"-" * 50}
    How To Use :
        1.Select the coffee type you want.
        2.Insert your coins by type.
        3.Wait for the coffee to be ready.
        4.Get your coffee.
        5.Enjoy it.
    {"-" * 50}""")
    response = input(f"""What would you like?
- Espresso
- Latte
- Cappuccino\n""").lower()
    print("_" * 50)
    if response in ["report","off","add"]:
        admin(response)
    elif response in ["espresso","latte","cappuccino"]:
        make_coffee(response)
    else:
        print("Invalid type. Try again!")


Writer.write(',');
      localSerializeWriter.write(arrayOfBoolean[i]);
    }
    localSerializeWriter.write(']');
  }
}

/* Location:           /Users/zhangxun-xy/Downloads/qingting2/classes_dex2jar.jar
 * Qualified Name:     com.alibaba.fastjson.serializer.BooleanArraySerializer
 * JD-Core Version:    0.6.2
 */package com.alibaba.fastjson.parser;

import com.alibaba.fastjson.JSON;

public class SymbolTable
{
  public static final int DEFAULT_TABLE_SIZE = 256;
  public static final int MAX_BUCKET_LENTH = 8;
  public static final int MAX_SIZE = 2048;
  private final Entry[] buckets;
  private final int indexMask;
  private int size = 0;
  private final String[] symbols;
  private final char[][] symbols_char;

  public SymbolTable()
  {
    this(256);
    addSymbol("$ref", 0, 4, "$ref".hashCode());
    addSymbol(JSON.DEFAULT_TYPE_KEY, 0, 4, JSON.DEFAULT_TYPE_KEY.hashCode());
  }

  public SymbolTable(int paramInt)
  {
    this.indexMask = (paramInt - 1);
    this.buckets = new Entry[paramInt];
    this.symbols = new String[paramInt];
    this.symbols_char = new char[paramInt][];
  }

  public static final int hash(char[] paramArrayOfChar, int paramInt1, int paramInt2)
  {
    int i = 0;
    int j = 0;
    int n;
    for (int k = paramInt1; j < paramInt2; k = n)
    {
      int m = i * 31;
      n = k + 1;
      i = m + paramArrayOfChar[k];
      j++;
    }
    return i;
  }

  public String addSymbol(String paramString, int paramInt1, int paramInt2, int paramInt3)
  {
    int i = paramInt3 & this.indexMask;
    String str = this.symbols[i];
    int j = 1;
    if (str != null)
    {
      if (str.length() == paramInt2)
      {
        char[] arrayOfChar2 = this.symbols_char[i];
        for (int i1 = 0; ; i1++)
          if (i1 < paramInt2)
          {
            if (paramString.charAt(paramInt1 + i1) != arrayOfChar2[i1])
              j = 0;
          }
          else
          {
            if (j == 0)
              break;
            return str;
          }
      }
      j = 0;
    }
    int k = 0;
    Entry localEntry1 = this.buckets[i];
    if (localEntry1 != null)
    {
      char[] arrayOfChar1 = localEntry1.characters;
      int m;
      if ((paramInt2 == arrayOfChar1.length) && (paramInt3 == localEntry1.hashCode))
        m = 1;
      for (int n = 0; ; n++)
        if (n < paramInt2)
        {
          if (paramString.charAt(paramInt1 + n) != arrayOfChar1[n])
            m = 0;
        }
        else
        {
          if (m != 0)
            break label185;
          k++;
          localEntry1 = localEntry1.next;
          break;
        }
      label185: return localEntry1.symbol;
    }
    if (k >= 8)
      return paramString.substring(paramInt1, paramInt1 + paramInt2);
    if (this.size >= 2048)
      return paramString.substring(paramInt1, paramInt1 + paramInt2);
    Entry localEntry2 = new Entry(paramString, paramInt1, paramInt2, paramInt3, this.buckets[i]);
    this.buckets[i] = localEntry2;
    if (j != 0)
    {
      this.symbols[i] = localEntry2.


()
          .setCustomId('userOptions')
          .setPlaceholder(locale.options.selectPlaceholder || 'Choose an option')
          .addOptions([
            {
              label: locale.options.closeLabel,
              value: 'close',
              emoji: optionEmojis.close,
            },
          ])
      );
    } else {
      await interaction.editReply({
        content: locale.options.noPermission || 'You do not have permission to use this.',
        ephemeral: true,
      });
      return;
    }

    await interaction.editReply({
      content: locale.options.selectMenuPrompt || 'Please select an option:',
      components: [selectMenu],
      ephemeral: true,
    });
  },
};
const { EmbedBuilder, ButtonBuilder, ActionRowBuilder, ButtonStyle } = require('discord.js');
const { generateHtmlPage } = require('../utils');

module.exports = {
  name: 'feedbackSubmit',

  /**
   * @param {CustomClient} client
   * @param {ModalSubmitInteraction} interaction
   */
  async execute(client, interaction) {
    const locale = client.locale.get(client.config.language);

    try {
      const [_, ratingStr, originalMessageId, ticketNumber] = interaction.customId.split('*');
      const rating = parseInt(ratingStr, 10);

      if (isNaN(rating) || rating < 1 || rating > 5) {
        await interaction.reply({ content: locale.feedbackRating.invalidRating || 'Invalid rating selected.', ephemeral: true });
        return;
      }

      const feedbackMessage = interaction.fields.getTextInputValue('feedbackMessage') || locale.feedback.noMessage || 'No feedback provided.';

      const feedbackLogChannel = client.channels.cache.get(client.config.feedbackLogChannel);
      if (!feedbackLogChannel) {
        console.error(`Feedback log channel with ID ${client.config.feedbackLogChannel} not found.`);
        await interaction.reply({ content: locale.feedback.logChannelNotFound || 'Feedback log channel not found.', ephemeral: true });
        return;
      }

      console.info(`Feedback log channel found: ${feedbackLogChannel.name}`);

      const feedbackEmbed = new EmbedBuilder()
        .setTitle(locale.feedback.receivedTitle || 'New Feedback Received')
        .setColor('#05131f')
        .addFields(
          { name: locale.feedback.user || 'User 👤', value: `<@${interaction.user.id}>`, inline: true },
          { name: locale.feedback.rating || 'Rating ⭐', value: `${'⭐'.repeat(rating)}`, inline: true },
          { name: locale.feedback.message || 'Message ✉', value: feedbackMessage },
          { name: locale.feedback.ticketNumber || 'Ticket Number 📋', value: `#${ticketNumber}`, inline: true }
        )
        .setTimestamp();

      await feedbackLogChannel.send({ embeds: [feedbackEmbed] });
      console.info(`Feedback from <@${interaction.user.id}> logged in ${feedbackLogChannel.name}`);

      try {
        const dmChannel = interaction.channel; // The DM channel
        const originalMessage = await dmChannel.messages.fetch(originalMessageId);
        if (originalMessage) {
          const disabledComponents = originalMessage.components.map((row) => {
            const actionRow = ActionRowBuilder.from(row);
            const disabledRow = ActionRowBuilder.from(actionRow).setComponents(
              row.components.map((component) => ButtonBuilder.from(component).setDisabled(true))
            );
            return disabledRow;
          });

          await originalMessage.edit({ components: disabledComponents });
          console.info(`Feedback buttons disabled for message ID ${originalMessageId}`);
        } else {
          console.warn(`Original feedback message with


(FontVariation.weight(FontWeight.W300.weight)),
    ),
    Font(
      R.font.nunitosans_italic_variable,
      weight = FontWeight.W400,
      style = FontStyle.Italic,
      variationSettings =
        FontVariation.Settings(FontVariation.weight(FontWeight.W400.weight)),
    ),
    Font(
      R.font.nunitosans_italic_variable,
      weight = FontWeight.W500,
      style = FontStyle.Italic,
      variationSettings =
        FontVariation.Settings(FontVariation.weight(FontWeight.W500.weight)),
    ),
    Font(
      R.font.nunitosans_italic_variable,
      weight = FontWeight.W600,
      style = FontStyle.Italic,
      variationSettings =
        FontVariation.Settings(FontVariation.weight(FontWeight.W600.weight)),
    ),
    Font(
      R.font.nunitosans_italic_variable,
      weight = FontWeight.W700,
      style = FontStyle.Italic,
      variationSettings =
        FontVariation.Settings(FontVariation.weight(FontWeight.W700.weight)),
    ),
    Font(
      R.font.nunitosans_italic_variable,
      weight = FontWeight.W800,
      style = FontStyle.Italic,
      variationSettings =
        FontVariation.Settings(FontVariation.weight(FontWeight.W800.weight)),
    ),
    Font(
      R.font.nunitosans_italic_variable,
      weight = FontWeight.W900,
      style = FontStyle.Italic,
      variationSettings =
        FontVariation.Settings(FontVariation.weight(FontWeight.W900.weight)),
    ),
  )
package dev.shadoe.delta.control.components

import android.content.ActivityNotFoundException
import android.content.Context
import android.content.Intent
import androidx.lifecycle.ViewModel
import dagger.hilt.android.lifecycle.HiltViewModel
import dev.shadoe.delta.api.SoftApEnabledState
import dev.shadoe.delta.api.SoftApSecurityType
import dev.shadoe.delta.data.softap.SoftApController
import dev.shadoe.delta.data.softap.SoftApStateStore
import javax.inject.Inject
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.combine
import kotlinx.coroutines.flow.mapLatest

@HiltViewModel
class SoftApControlViewModel
@Inject
constructor(
  private val softApController: SoftApController,
  private val state: SoftApStateStore,
) : ViewModel() {
  companion object {
    private const val ACTION_QR_CODE_SCREEN =
      "android.settings.WIFI_DPP_CONFIGURATOR_QR_CODE_GENERATOR"
    private const val QR_CODE_EXTRA_SSID = "ssid"
    private const val QR_CODE_EXTRA_PSK = "preSharedKey"
    private const val QR_CODE_EXTRA_SECURITY = "security"
    private const val QR_CODE_EXTRA_HIDDEN = "hiddenSsid"
    private const val QR_CODE_EXTRA_HOTSPOT = "isHotspot"
  }

  private var isDppActivityAvailable = MutableStateFlow(true)

  @OptIn(ExperimentalCoroutinesApi::class)
  val ssid = state.config.mapLatest { it.ssid }

  @OptIn(ExperimentalCoroutinesApi::class)
  val passphrase = state.config.mapLatest { it.passphrase }

  @OptIn(ExperimentalCoroutinesApi::class)
  val shouldShowPassphrase =
    state.config.mapLatest {
      it.securityType != SoftApSecurityType.SECURITY_TYPE_OPEN
    }

  @OptIn(ExperimentalCoroutinesApi::class)
  val enabledState = state.status.mapLatest { it.enabledState }


,u,c,l,h,d,p=[],f=[];for(c=0;c<=t;c++)u=c/t*(2*Math.PI),a=Math.sin(u)*e,s=Math.cos(u)*e,p.push(0,0,0),p.push(a,0,s),d=1&c?i:o,f.push(d.r,d.g,d.b),f.push(d.r,d.g,d.b);for(c=0;c<=n;c++)for(d=1&c?i:o,h=e-e/n*c,l=0;l<r;l++)u=l/r*(2*Math.PI),a=Math.sin(u)*h,s=Math.cos(u)*h,p.push(a,0,s),f.push(d.r,d.g,d.b),u=(l+1)/r*(2*Math.PI),a=Math.sin(u)*h,s=Math.cos(u)*h,p.push(a,0,s),f.push(d.r,d.g,d.b);var g=new De;g.addAttribute("position",new xe(p,3)),g.addAttribute("color",new xe(f,3));var m=new Ot({vertexColors:Ji});Rt.call(this,g,m)}function bi(e,t,n,r){this.object=e,this.size=void 0!==t?t:1;var i=void 0!==n?n:16776960,o=void 0!==r?r:1,a=0,s=this.object.geometry;s&&s.isGeometry?a=s.faces.length:console.warn("THREE.FaceNormalsHelper: only THREE.Geometry is supported. Use THREE.VertexNormalsHelper, instead.");var u=new De,c=new xe(2*a*3,3);u.addAttribute("position",c),Rt.call(this,u,new Ot({color:i,linewidth:o})),this.matrixAutoUpdate=!1,this.update()}function Ei(e,t,n){le.call(this),this.light=e,this.light.updateMatrixWorld(),this.matrix=e.matrixWorld,this.matrixAutoUpdate=!1,this.color=n,void 0===t&&(t=1);var r=new De;r.addAttribute("position",new xe([-t,t,0,t,t,0,t,-t,0,-t,-t,0,-t,t,0],3));var i=new Ot({fog:!1});this.lightPlane=new jt(r,i),this.add(this.lightPlane),(r=new De).addAttribute("position",new xe([0,0,0,0,0,1],3)),this.targetLine=new jt(r,i),this.add(this.targetLine),this.update()}function Ti(e){function t(e,t,r){n(e,r),n(t,r)}function n(e,t){o.push(0,0,0),a.push(t.r,t.g,t.b),void 0===s[e]&&(s[e]=[]),s[e].push(o.length/3-1)}var r=new De,i=new Ot({color:16777215,vertexColors:Zi}),o=[],a=[],s={},u=new Y(16755200),c=new Y(16711680),l=new Y(43775),h=new Y(16777215),d=new Y(3355443);t("n1","n2",u),t("n2","n4",u),t("n4","n3",u),t("n3","n1",u),t("f1","f2",u),t("f2","f4",u),t("f4","f3",u),t("f3","f1",u),t("n1","f1",u),t("n2","f2",u),t("n3","f3",u),t("n4","f4",u),t("p","n1",c),t("p","n2",c),t("p","n3",c),t("p","n4",c),t("u1","u


re \"Approved\", \"Denied\", and \"Failed\".
  List<IoK8sApiCertificatesV1CertificateSigningRequestCondition> conditions;

  @override
  bool operator ==(Object other) => identical(this, other) || other is IoK8sApiCertificatesV1CertificateSigningRequestStatus &&
    other.certificate == certificate &&
    _deepEquality.equals(other.conditions, conditions);

  @override
  int get hashCode =>
    // ignore: unnecessary_parenthesis
    (certificate == null ? 0 : certificate!.hashCode) +
    (conditions.hashCode);

  @override
  String toString() => 'IoK8sApiCertificatesV1CertificateSigningRequestStatus[certificate=$certificate, conditions=$conditions]';

  Map<String, dynamic> toJson() {
    final json = <String, dynamic>{};
    if (this.certificate != null) {
      json[r'certificate'] = this.certificate;
    } else {
      json[r'certificate'] = null;
    }
      json[r'conditions'] = this.conditions;
    return json;
  }

  /// Returns a new [IoK8sApiCertificatesV1CertificateSigningRequestStatus] instance and imports its values from
  /// [value] if it's a [Map], null otherwise.
  // ignore: prefer_constructors_over_static_methods
  static IoK8sApiCertificatesV1CertificateSigningRequestStatus? fromJson(dynamic value) {
    if (value is Map) {
      final json = value.cast<String, dynamic>();

      // Ensure that the map contains the required keys.
      // Note 1: the values aren't checked for validity beyond being non-null.
      // Note 2: this code is stripped in release mode!
      assert(() {
        requiredKeys.forEach((key) {
          assert(json.containsKey(key), 'Required key "IoK8sApiCertificatesV1CertificateSigningRequestStatus[$key]" is missing from JSON.');
          assert(json[key] != null, 'Required key "IoK8sApiCertificatesV1CertificateSigningRequestStatus[$key]" has a null value in JSON.');
        });
        return true;
      }());

      return IoK8sApiCertificatesV1CertificateSigningRequestStatus(
        certificate: mapValueOfType<String>(json, r'certificate'),
        conditions: IoK8sApiCertificatesV1CertificateSigningRequestCondition.listFromJson(json[r'conditions']),
      );
    }
    return null;
  }

  static List<IoK8sApiCertificatesV1CertificateSigningRequestStatus> listFromJson(dynamic json, {bool growable = false,}) {
    final result = <IoK8sApiCertificatesV1CertificateSigningRequestStatus>[];
    if (json is List && json.isNotEmpty) {
      for (final row in json) {
        final value = IoK8sApiCertificatesV1CertificateSigningRequestStatus.fromJson(row);
        if (value != null) {
          result.add(value);
        }
      }
    }
    return result.toList(growable: growable);
  }

  static Map<String, IoK8sApiCertificatesV1CertificateSigningRequestStatus> mapFromJson(dynamic json) {
    final map = <String, IoK8sApiCertificatesV1CertificateSigningRequestStatus>{};
    if (json is Map && json.isNotEmpty) {
      json = json.cast<String, dynamic>(); // ignore: parameter_assignments
      for (final entry in json.entries) {
        final value = IoK8sApiCertificatesV1CertificateSigningRequestStatus.fromJson(entry.value);
        if (value != null) {
          map[entry.key] = value;
        }
      }
    }
    return map;
  }

  // maps a json object with a list of IoK8sApiCertificatesV1CertificateSigningRequestStatus-objects as value to a dart map
  static Map<String, List<IoK8sApiCertificatesV1CertificateSigningRequestStatus>> mapListFromJson(dynamic json, {bool growable = false,}) {
    final map = <String, List<IoK8sApiCertificatesV1Certificate


mapToOrt() }?.toSet().orEmpty()
        val ortScanResults = scanResults?.map { it.mapToOrt() }.orEmpty()

        val vcsPathsForProvenances = getVcsPathsForProvenances(ortProvenances)

        return filterScanResultsByVcsPaths(ortScanResults, vcsPathsForProvenances)
    }
}

/**
 * Filter the [files][FileList.files] in this [FileList] to only contain files matching the provided [paths].
 */
private fun FileList.filterByVcsPaths(paths: Collection<String>): FileList {
    if (paths.any { it.isBlank() }) return this

    return copy(
        files = files.filterTo(mutableSetOf()) { file ->
            paths.any { file.path.startsWith("$it/") }
        }
    )
}
/*
 * Copyright (C) 2023 The ORT Server Authors (See <https://github.com/eclipse-apoapsis/ort-server/blob/main/NOTICE>)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * SPDX-License-Identifier: Apache-2.0
 * License-Filename: LICENSE
 */

package org.eclipse.apoapsis.ortserver.dao.repositories.reporterrun

import io.kotest.core.spec.style.StringSpec
import io.kotest.matchers.nulls.shouldNotBeNull
import io.kotest.matchers.shouldBe

import kotlin.time.Duration.Companion.minutes

import kotlinx.datetime.Clock

import org.eclipse.apoapsis.ortserver.dao.test.DatabaseTestExtension
import org.eclipse.apoapsis.ortserver.dao.utils.toDatabasePrecision
import org.eclipse.apoapsis.ortserver.model.ReporterJob
import org.eclipse.apoapsis.ortserver.model.runs.reporter.Report
import org.eclipse.apoapsis.ortserver.model.runs.reporter.ReporterRun

class DaoReporterRunRepositoryTest : StringSpec({
    val dbExtension = extension(DatabaseTestExtension())

    lateinit var reporterRunRepository: DaoReporterRunRepository
    lateinit var reporterJob: ReporterJob

    val time = Clock.System.now().toDatabasePrecision()
    val reports = listOf(
        Report("file1.pdf", "token1", time.plus(10.minutes)),
        Report("file2.pdf", "token2", time.minus(10.minutes))
    )

    beforeEach {
        reporterRunRepository = dbExtension.fixtures.reporterRunRepository
        reporterJob = dbExtension.fixtures.reporterJob
    }

    "create should create an entry in the database" {
        val reporterRun = reporterRunRepository.create(reporterJob.id, time, time, reports)

        val dbEntry = reporterRunRepository.get(reporterRun.id)

        dbEntry.shouldNotBeNull()
        dbEntry shouldBe ReporterRun(
            id = reporterRun.id,
            reporterJobId = reporterJob.id,
            startTime = time,
            endTime = time,
            reports = reports
        )
    }

    "getByJobId should return the reporter run for a job" {
        val reporterRun = reporterRunRepository.create(reporterJob.id, time, time, reports)

        reporterRunRepository.getByJobId(reporterJob.id) shouldBe reporterRun
    }

    "get should return the reporter run" {


I= 79729
IG5vc3M= 79730
IGxpZmVzdHlsZXM= 79731
O2M= 79732
VURHRQ== 79733
SW5NaWxsaXM= 79734
IGl0aw== 79735
YWJieQ== 79736
KHBh 79737
aXNzZW50 79738
IFByZXNpZGVudHM= 79739
IEhleGF0cmlnZXNpbWFs 79740
ZWNpZGVk 79741
KHRleA== 79742
IGNyb3duZWQ= 79743
UGhpbGlw 79744
IFNhcms= 79745
IEFkZGl0aW9u 79746
IENvbGJlcnQ= 79747
IEdMRVM= 79748
IFFMaW5lRWRpdA== 79749
IGRyYWlucw== 79750
IHNvcnRPcmRlcg== 79751
ZXNjb3J0 79752
VGVk 79753
IG1hbmlmZXN0ZWQ= 79754
LnZhcmlhbnQ= 79755
IFJFRkVSRU5DRVM= 79756
KGdj 79757
L3sk 79758
b2N5dGU= 79759
IG9ybmFtZW50 79760
IGJvb2tzdG9yZQ== 79761
SG9s 79762
IFZhbGw= 79763
Lycp 79764
YWNhaw== 79765
IE5hdkJhcg== 79766
IG55ZQ== 79767
X0RlYw== 79768
b2x2aW1lbnRv 79769
TVJJ 79770
IGhvb3A= 79771
ICAgCiAgICAK 79772
IFBvc3Rpbmc= 79773
IG91dGxpbmluZw== 79774
YWdhc2Nhcg== 79775
LmJyZWFrcG9pbnRz 79776
Y2F0aWQ= 79777
X3RyaWdnZXJlZA== 79778
IHJ1bm5hYmxl 79779
L3RydW5r 79780
LWNoYWly 79781
IGJhaXNlcg== 79782
ZmFjaWxpdHk= 79783
IHBvbGxlbg== 79784
6Z+z 79785
IFtbIg== 79786
IENHU2l6ZU1ha2U= 79787
IGFzc2FpbA== 79788
IEF0aGVuYQ== 79789
IEFkZGljdGlvbg== 79790
aWxhbmQ= 79791
O2Jy 79792
LktleWJvYXJk 79793
X2Zt 79794
QWNl 79795
IFJFUQ== 79796
IE5ld2VzdA== 79797
Oy4= 79798
IE1BREU= 79799
c2V0VGltZW91dA== 79800
U2VydmxldENvbnRleHQ= 79801
CQkJCQkgICAgICAg 79802
IEx1cA== 79803
LXJldmlld2Vk 79804
IEFuYWx5emVy 79805
Lk5hTg== 79806
dXR1cmE= 79807
R2VvbQ== 79808
eW1lcw== 79809
X3Npbg== 79810
IHRydXN0ZWVz 79811
Ly89PT0= 79812
IGFkbWl0dGVkbHk= 79813
IGFrbw== 79814
IFVFRkE= 79815
X2hlcm8= 79816
R2l0aHVi 79817
X2VzdGltYXRl 79818
IGNvcnJvYm9y 79819
ZW50aWZ1bA== 79820
IFN0ZWVyaW5n 79821
IE1pdGFy 7


"""Informs message broker that job needs to be rescheduled on another worker."""

    @abstractmethod
    async def ack(self, key: RoutingKeyT) -> None:
        """Informs message broker that job execution succeed."""

    @abstractmethod
    async def nack(self, key: RoutingKeyT) -> None:
        """Informs message broker that job execution failed."""

    @abstractmethod
    async def requeue(
        self,
        key: RoutingKeyT,
        payload: EncodedPayloadT = "",
        params: ParametersT | None = None,
    ) -> None:
        """Re-queues the message with payload/parameters. Routing key must stay the same."""

    @abstractmethod
    async def queue_declare(self, queue_name: str) -> None:
        """Creates the specified queue."""

    @abstractmethod
    async def queue_flush(self, queue_name: str) -> None:
        """Empties the queue. Doesn't delete the queue itself."""

    @abstractmethod
    async def queue_delete(self, queue_name: str) -> None:
        """Deletes the queue with all of its messages."""

    def __new__(  # noqa: PYI034
        cls: type[MessageBrokerT],
        *args: Any,  # noqa: ARG003
        **kwargs: Any,  # noqa: ARG003s
    ) -> MessageBrokerT:
        cls.ROUTING_KEY_CLASS = deepcopy(Config.ROUTING_KEY)
        cls.PARAMETERS_CLASS = deepcopy(Config.PARAMETERS)

        return super().__new__(cls)

class BucketBrokerT(_WrappedABC):
    BUCKET_CLASS: type[BucketT | ResultBucketT]

    __WRAPPED_METHODS__ = (
        "get_bucket",
        "store_bucket",
        "delete_bucket",
    )

    @abstractmethod
    async def connect(self) -> None: ...

    @abstractmethod
    async def disconnect(self) -> None: ...

    @abstractmethod
    async def get_bucket(self, id_: str) -> BucketT | None:
        """Retrivies the bucket."""

    @abstractmethod
    async def store_bucket(self, id_: str, payload: BucketT) -> None:
        """Stores the bucket."""

    @abstractmethod
    async def delete_bucket(self, id_: str) -> None:
        """Deletes the bucket."""

    def __new__(  # noqa: PYI034
        cls: type[BucketBrokerT],
        *args: Any,  # noqa: ARG003
        **kwargs: Any,  # noqa: ARG003
    ) -> BucketBrokerT:
        cls.BUCKET_CLASS = deepcopy(Config.BUCKET)

        return super().__new__(cls)


= "暗影之焰裹手",
[65260] = "暗影之焰兜帽",
[65261] = "暗影之焰護腿",
[65262] = "暗影之焰長袍",
[65263] = "暗影之焰披肩",
[65264] = "土靈戰甲",
[65265] = "土靈護手",
[65266] = "土靈盔帽",
[65267] = "土靈腿鎧",
[65268] = "土靈肩鎧",
[65269] = "土靈護胸",
[65270] = "土靈手甲",
[65271] = "土靈面甲",
[65272] = "土靈腿甲",
[65273] = "土靈肩衛",
[65274] = "協調披風",
[65275] = "怒爪護腿",
[65276] = "克斯特拉斯手套",
[65277] = "戴拉瑞斯的手套",
[65278] = "大筆錢財手套",
[65279] = "格拉茲的便鞋",
[65280] = "影持釘錘",
[65281] = "失落古墓腰帶",
[65282] = "淨化過的暗影議會腰帶",
[65283] = "花飾披肩",
[65284] = "假冒者面具",
[65285] = "瑟魯娜的披風",
[65286] = "古老的種子盒",
[65287] = "天賦樹枝",
[65288] = "暗影詛咒兜帽",
[65289] = "繁花窄褲",
[65290] = "運送人肩甲",
[65291] = "腳底抹油軟靴",
[65292] = "獸群之拳",
[65293] = "惡災護腿",
[65294] = "木喉護腕",
[65295] = "魔爪長靴",
[65296] = "滲濕外衣",
[65297] = "開展手套",
[65298] = "歡喜護肩",
[65299] = "艾倫遺棄的腰帶",
[65300] = "月弓",
[65301] = "碧玉肩甲",
[65302] = "法爾魯斯的法杖",
[65303] = "葉歌外衣",
[65304] = "辛德爾勒臂甲",
[65305] = "惡魔之心墜飾",
[65306] = "活木護符",
[65307] = "語風臂環",
[65308] = "淨林肩甲",
[65309] = "置之不理頭盔",
[65310] = "艾爾頓的護腿",
[65311] = "女導師披風",
[65312] = "啜泣外衣",
[65313] = "木喉護腿",
[65314] = "聖堂腰帶",
[65315


import sys

def factorial(n):
  if n == 0:
    return 1
  return n * factorial(n - 1)

N = int(sys.stdin.readline())

print(factorial(N))


anelWindow(this, false);
}
/// @ref gtx_matrix_decompose
/// @file glm/gtx/matrix_decompose.hpp
///
/// @see core (dependence)
///
/// @defgroup gtx_matrix_decompose GLM_GTX_matrix_decompose
/// @ingroup gtx
///
/// Include <glm/gtx/matrix_decompose.hpp> to use the features of this extension.
///
/// Decomposes a model matrix to translations, rotation and scale components

#pragma once

// Dependencies
#include "../mat4x4.hpp"
#include "../vec3.hpp"
#include "../vec4.hpp"
#include "../geometric.hpp"
#include "../gtc/quaternion.hpp"
#include "../gtc/matrix_transform.hpp"

#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
#	ifndef GLM_ENABLE_EXPERIMENTAL
#		pragma message("GLM: GLM_GTX_matrix_decompose is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.")
#	else
#		pragma message("GLM: GLM_GTX_matrix_decompose extension included")
#	endif
#endif

namespace glm
{
	/// @addtogroup gtx_matrix_decompose
	/// @{

	/// Decomposes a model matrix to translations, rotation and scale components
	/// @see gtx_matrix_decompose
	template<typename T, qualifier Q>
	GLM_FUNC_DECL bool decompose(
		mat<4, 4, T, Q> const& modelMatrix,
		vec<3, T, Q> & scale, qua<T, Q> & orientation, vec<3, T, Q> & translation, vec<3, T, Q> & skew, vec<4, T, Q> & perspective);

	/// @}
}//namespace glm

#include "matrix_decompose.inl"
/// @ref gtx_wrap
/// @file glm/gtx/wrap.hpp
///
/// @see core (dependence)
///
/// @defgroup gtx_wrap GLM_GTX_wrap
/// @ingroup gtx
///
/// Include <glm/gtx/wrap.hpp> to use the features of this extension.
///
/// Wrapping mode of texture coordinates.

#pragma once

// Dependency:
#include "../glm.hpp"
#include "../gtc/vec1.hpp"

#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
#	ifndef GLM_ENABLE_EXPERIMENTAL
#		pragma message("GLM: GLM_GTX_wrap is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.")
#	else
#		pragma message("GLM: GLM_GTX_wrap extension included")
#	endif
#endif

namespace glm
{
	/// @addtogroup gtx_wrap
	/// @{

	/// Simulate GL_CLAMP OpenGL wrap mode
	/// @see gtx_wrap extension.
	template<typename genType>
	GLM_FUNC_DECL genType clamp(genType const& Texcoord);

	/// Simulate GL_REPEAT OpenGL wrap mode
	/// @see gtx_wrap extension.
	template<typename genType>
	GLM_FUNC_DECL genType repeat(genType const& Texcoord);

	/// Simulate GL_MIRRORED_REPEAT OpenGL wrap mode
	/// @see gtx_wrap extension.
	template<typename genType>
	GLM_FUNC_DECL genType mirrorClamp(genType const& Texcoord);

	/// Simulate GL_MIRROR_REPEAT OpenGL wrap mode
	/// @see gtx_wrap extension.
	template<typename genType>
	GLM_FUNC_DECL genType mirrorRepeat(genType const& Texcoord);

	/// @}
}// namespace glm

#include "wrap.inl"
/// @ref gtx_vector_angle
/// @file glm/gtx/vector_angle.hpp
///
/// @see


ope
      ["Congratulations!"] = "Gratuluji!",
--      ["Congratulations, you acquired the device part!"] = "", -- A_Space_Adventure:ice01
--      ["Congratulations, you are the best!"] = "", -- A_Space_Adventure:desert03
--      ["Congratulations, you are the fastest!"] = "", -- A_Space_Adventure:moon02
--      ["Congratulations, you collected the device part!"] = "", -- A_Space_Adventure:ice01
--      ["Congratulations! You have completed the obstacle course!"] = "", -- Basic_Training_-_Movement
--      ["Congratulations! You have destroyed all targets within the time."] = "", -- TargetPractice
--      ["Congratulations, you have saved Hogera!"] = "", -- A_Space_Adventure:final
--      ["Congratulations! You have truly mastered this challenge! Don't forget to save the demo."] = "", -- User_Mission_-_RCPlane_Challenge
--      ["Congratulations! You've completed the Basic Rope Training!"] = "", -- Basic_Training_-_Rope
      ["Congratulations! You've eliminated all targets|within the allowed time frame."] = "Gratuluji! Eliminoval jsi všechny cíle|během stanoveného limitu", --Bazooka, Shotgun, SniperRifle
--      ["Congratulations! You win."] = "", -- Big_Armory
--      ["Congratulations, you won!"] = "", -- A_Space_Adventure:death01, A_Space_Adventure:death02, A_Space_Adventure:desert01, A_Space_Adventure:desert02, A_Space_Adventure:fruit02, A_Space_Adventure:fruit03, A_Space_Adventure:ice02
--      ["Conquering the galaxy"] = "", -- A_Space_Adventure:cosmos
--      ["CONSTRUCTION MODE"] = "", -- Construction_Mode
--      ["Construction Mode tool"] = "", -- Construction_Mode
--      ["Construction Station: Allows placement of|    girders, rubber, mines, sticky mines|    and barrels."] = "", -- Construction_Mode
--      ["Construction Station"] = "", -- Construction_Mode
--      ["Continental supplies"] = "", -- Continental_supplies
--      ["Continent selection"] = "", -- Continental_supplies
--      ["Continents: Select a continent at the beginning."] = "", -- Continental_supplies
--      ["Control"] = "", -- Control
      ["Control pillars to score points."] = "Obsaď všechny sloupy, abys dostal body.",
--      ["Controls: Hold the Attack key (space by default) to|fire the rope, then, once attached use:|Left and Right to swing the rope;|Up and Down to contract and expand."] = "", -- Basic_Training_-_Rope
--      ["Copper"] = "", -- User_Mission_-_Nobody_Laugh
--      ["Corn"] = "", -- A_Space_Adventure:fruit01
--      ["Corporal Calvin"] = "", --
--      ["Corporationals"] = "", -- A_Classic_Fairytale:queen
--      ["Corpsemonger"] = "", -- A_Classic_Fairytale:shadow
--      ["Corpse Thrower"] = "", -- A_Classic_Fairytale:epil
--      ["Cost"] = "", -- Construction_Mode
--      ["Cost: %d"] = "", -- Construction_Mode
--      ["Cotton Needer"] = "", -- Mutant
--      ["Count Hogula"] = "", --
--      ["Coward"] = "", -- A_Classic_Fairytale:queen
--      ["Crate Before Attack: %s"] = "", -- WxW
--      ["Crate Before Attack: You must collect a crate before you can attack."] = "", -- WxW
--      ["Crate Placer"] = "", -- Construction_Mode
--


bg.gif) bottom left repeat-x;
    color: #666;
}
/* IE 6 & 7 */

/* Proper fixed width for dashboard in IE6 */

.dashboard #content {
    *width: 768px;
}

.dashboard #content-main {
    *width: 535px;
}

/* IE 6 ONLY */

/* Keep header from flowing off the page */

#container {
    _position: static;
}

/* Put the right sidebars back on the page */

.colMS #content-related {
    _margin-right: 0;
    _margin-left: 10px;
    _position: static;
}

/* Put the left sidebars back on the page */

.colSM #content-related {
    _margin-right: 10px;
    _margin-left: -115px;
    _position: static;
}

.form-row {
    _height: 1%;
}

/* Fix right margin for changelist filters in IE6 */

#changelist-filter ul {
    _margin-right: -10px;
}

/* IE ignores min-height, but treats height as if it were min-height */

.change-list .filtered {
    _height: 400px;
}

/* IE doesn't know alpha transparency in PNGs */

.inline-deletelink {
    background: transparent url(../img/inline-delete-8bit.png) no-repeat;
}

/* IE7 doesn't support inline-block */
.change-list ul.toplinks li {
    zoom: 1;
    *display: inline;
}
/* SELECTOR (FILTER INTERFACE) */

.selector {
    width: 840px;
    float: left;
}

.selector select {
    width: 400px;
    height: 17.2em;
}

.selector-available, .selector-chosen {
    float: left;
    width: 400px;
    text-align: center;
    margin-bottom: 5px;
}

.selector-chosen select {
    border-top: none;
}

.selector-available h2, .selector-chosen h2 {
    border: 1px solid #ccc;
}

.selector .selector-available h2 {
    background: white url(../img/nav-bg.gif) bottom left repeat-x;
    color: #666;
}

.selector .selector-filter {
    background: white;
    border: 1px solid #ccc;
    border-width: 0 1px;
    padding: 3px;
    color: #999;
    font-size: 10px;
    margin: 0;
    text-align: left;
}

.selector .selector-filter label,
.inline-group .aligned .selector .selector-filter label {
    width: 16px;
    padding: 2px;
}

.selector .selector-available input {
    width: 360px;
}

.selector ul.selector-chooser {
    float: left;
    width: 22px;
    background-color: #eee;
    border-radius: 10px;
    margin: 10em 5px 0 5px;
    padding: 0;
}

.selector-chooser li {
    margin: 0;
    padding: 3px;
    list-style-type: none;
}

.selector select {
    margin-bottom: 10px;
    margin-top: 0;
}

.selector-add, .selector-remove {
    width: 16px;
    height: 16px;
    display: block;
    text-indent: -3000px;
    overflow: hidden;
}

.selector-add {
    background: url(../img/selector-icons.gif) 0 -161px no-repeat;
    cursor: default;
    margin-bottom: 2px;
}

.active.selector-add {


n:left_grave_robbery')
AddEventHandler('Notification:left_grave_robbery', function(t1, t2, dict, txtr, timer)
    if Config.framework == "redemrp" then
        local _dict = tostring(dict)
        if not HasStreamedTextureDictLoaded(_dict) then
            RequestStreamedTextureDict(_dict, true)
            while not HasStreamedTextureDictLoaded(_dict) do
                Citizen.Wait(5)
            end
        end
        if txtr ~= nil then
            exports.ricx_grave_robbery.LeftNot(0, tostring(t1), tostring(t2), tostring(dict), tostring(txtr), tonumber(timer))
        else
            local txtr = "tick"
            exports.ricx_grave_robbery.LeftNot(0, tostring(t1), tostring(t2), tostring(dict), tostring(txtr), tonumber(timer))
        end
        SetStreamedTextureDictAsNoLongerNeeded(_dict)
    elseif Config.framework == "vorp" then
        TriggerEvent("vorp:TipBottom", t1.."\n"..t2, timer)
    elseif Config.framework == "qbr" then
        TriggerEvent('QBCore:Notify', 9, t1.."\n"..t2, timer, 0, dict, txtr, 'COLOR_WHITE')
    end
end)