 + 2 ), l, matches);
										//line 182 "C:\\Users\\Dominik\\Brotli\\src\\encode\\Static_dict.hx"
										boolean tmp14 = false;
										//line 182 "C:\\Users\\Dominik\\Brotli\\src\\encode\\Static_dict.hx"
										java.lang.Object b57 = haxe.lang.StringExt.charCodeAt("T", 0);
										//line 182 "C:\\Users\\Dominik\\Brotli\\src\\encode\\Static_dict.hx"
										if (haxe.lang.Runtime.eq(((int) (((int[]) (data) )[( s_off + 2 )]) ), b57))
										{
											//line 182 "C:\\Users\\Dominik\\Brotli\\src\\encode\\Static_dict.hx"
											java.lang.Object b58 = haxe.lang.StringExt.charCodeAt("h", 0);
											//line 182 "C:\\Users\\Dominik\\Brotli\\src\\encode\\Static_dict.hx"
											tmp14 = haxe.lang.Runtime.eq(((int) (((int[]) (data) )[( s_off + 3 )]) ), b58);
										}
										else
										{
											//line 182 "C:\\Users\\Dominik\\Brotli\\src\\encode\\Static_dict.hx"
											tmp14 = false;
										}

										//line 182 "C:\\Users\\Dominik\\Brotli\\src\\encode\\Static_dict.hx"
										if (tmp14)
										{
											//line 183 "C:\\Users\\Dominik\\Brotli\\src\\encode\\Static_dict.hx"
											java.lang.Object b59 = haxe.lang.StringExt.charCodeAt("e", 0);
											//line 183 "C:\\Users\\Dominik\\Brotli\\src\\encode\\Static_dict.hx"
											if (haxe.lang.Runtime.eq(((int) (((int[]) (data) )[( s_off + 4 )]) ), b59))
											{
												//line 184 "C:\\Users\\Dominik\\Brotli\\src\\encode\\Static_dict.hx"
												java.lang.Object b60 = haxe.lang.StringExt.charCodeAt(" ", 0);
												//line 184 "C:\\Users\\Dominik\\Brotli\\src\\encode\\Static_dict.hx"
												if (haxe.lang.Runtime.eq(((int) (((int[]) (data) )[( s_off + 5 )]) ), b60))
												{
													//line 184 "C:\\Users\\Dominik\\Brotli\\src\\encode\\Static_dict.hx"
													encode.Static_dict.AddMatch(( id + ( 43 * n ) ), ( l + 6 ), l, matches);
												}

											}
											else
											{
												//line 185 "C:\\Users\\Dominik\\Brotli\\src\\encode\\Static_dict.hx"
												java.lang.Object b61 = haxe.lang.StringExt.charCodeAt("i", 0);
												//line 185 "C:\\Users\\Dominik\\Brotli\\src\\encode\\Static_dict.hx"
												if (haxe.lang.Runtime.eq(((int) (((int[]) (data) )[( s_off + 4 )]) ), b61))
												{
													//line 186 "C:\\Users\\Dominik\\Brotli\\src\\encode\\Static_dict.hx"
													boolean tmp15 = false;
													//line 186 "C:\\Users\\Dominik\\Brotli\\src\\encode\\Static_dict.hx"
													java.lang.Object b62 = haxe.lang.StringExt.charCodeAt("s", 0);
													//line 186 "C:\\Users\\Dominik\\Brotli\\src\\encode\\Static_dict.hx"
													if (haxe.lang.Runtime.eq(((int) (((int[]) (data) )[( s_off + 5 )]) ), b


</button>

              <input type="text" class="form-control form-control-lg" id="nik" placeholder="Nomor Induk Kependudukan / No KTP">

          <button type="button" class="btn btn-lg btn-secondary" data-dismiss="modal">Tutup</button>
          <button type="submit" id="daftar" class="btn btn-lg btn-primary">Daftar</button>


ear(0.1):diffusealpha(0) end,
		SwitchFocusToGroupsMessageCommand=function(self) self:sleep(0.25):linear(0.1):diffusealpha(1) end,
	},
}

-- Stage Number
if not PREFSMAN:GetPreference("EventMode") then
	af[#af+1] = Def.BitmapText{
		Font=PREFSMAN:GetPreference("EventMode") and "Wendy/_wendy monospace numbers" or "Common Header",
		Name="Stage Number",
		Text=SSM_Header_StageText(),
		InitCommand=function(self)
			self:diffusealpha(0):halign(1):zoom(0.5):x(_screen.w-8)
			if PREFSMAN:GetPreference("MenuTimer") then
				self:y(44)
			else
				self:y(34)
			end
		end,
		SwitchFocusToGroupsMessageCommand=function(self) self:linear(0.1):diffusealpha(0) end,
		SwitchFocusToSongsMessageCommand=function(self) self:sleep(0.25):linear(0.1):diffusealpha(1) end,
	}
end

return af


	{name: "CMPshiftLLreg", argLength: 3, reg: gp3flags, asm: "CMP", typ: "Flags"}, // arg0 compare to arg1<<arg2
		{name: "CMPshiftRLreg", argLength: 3, reg: gp3flags, asm: "CMP", typ: "Flags"}, // arg0 compare to arg1>>arg2, unsigned shift
		{name: "CMPshiftRAreg", argLength: 3, reg: gp3flags, asm: "CMP", typ: "Flags"}, // arg0 compare to arg1>>arg2, signed shift
		{name: "CMNshiftLLreg", argLength: 3, reg: gp3flags, asm: "CMN", typ: "Flags"}, // arg0 + (arg1<<arg2) compare to 0
		{name: "CMNshiftRLreg", argLength: 3, reg: gp3flags, asm: "CMN", typ: "Flags"}, // arg0 + (arg1>>arg2) compare to 0, unsigned shift
		{name: "CMNshiftRAreg", argLength: 3, reg: gp3flags, asm: "CMN", typ: "Flags"}, // arg0 + (arg1>>arg2) compare to 0, signed shift
		{name: "TSTshiftLLreg", argLength: 3, reg: gp3flags, asm: "TST", typ: "Flags"}, // arg0 & (arg1<<arg2) compare to 0
		{name: "TSTshiftRLreg", argLength: 3, reg: gp3flags, asm: "TST", typ: "Flags"}, // arg0 & (arg1>>arg2) compare to 0, unsigned shift
		{name: "TSTshiftRAreg", argLength: 3, reg: gp3flags, asm: "TST", typ: "Flags"}, // arg0 & (arg1>>arg2) compare to 0, signed shift
		{name: "TEQshiftLLreg", argLength: 3, reg: gp3flags, asm: "TEQ", typ: "Flags"}, // arg0 ^ (arg1<<arg2) compare to 0
		{name: "TEQshiftRLreg", argLength: 3, reg: gp3flags, asm: "TEQ", typ: "Flags"}, // arg0 ^ (arg1>>arg2) compare to 0, unsigned shift
		{name: "TEQshiftRAreg", argLength: 3, reg: gp3flags, asm: "TEQ", typ: "Flags"}, // arg0 ^ (arg1>>arg2) compare to 0, signed shift

		{name: "CMPF0", argLength: 1, reg: fp1flags, asm: "CMPF", typ: "Flags"}, // arg0 compare to 0, float32
		{name: "CMPD0", argLength: 1, reg: fp1flags, asm: "CMPD", typ: "Flags"}, // arg0 compare to 0, float64

		// moves
		{name: "MOVWconst", argLength: 0, reg: gp01, aux: "Int32", asm: "MOVW", typ: "UInt32", rematerializeable: true},    // 32 low bits of auxint
		{name: "MOVFconst", argLength: 0, reg: fp01, aux: "Float64", asm: "MOVF", typ: "Float32", rematerializeable: true}, // auxint as 64-bit float, convert to 32-bit float
		{name: "MOVDconst", argLength: 0, reg: fp01, aux: "Float64", asm: "MOVD", typ: "Float64", rematerializeable: true}, // auxint as 64-bit float

		{name: "MOVWaddr", argLength: 1, reg: regInfo{inputs: []regMask{buildReg("SP") | buildReg("SB")}, outputs: []regMask{gp}}, aux: "SymOff", asm: "MOVW", rematerializeable: true, symEffect: "Addr"}, // arg0 + auxInt + aux.(*gc.Sym), arg0=SP/SB

		{name: "MOVBload", argLength: 2, reg: gpload, aux: "SymOff", asm: "MOVB", typ: "Int8", faultOnNilArg0: true, symEffect: "Read"


ist
  ```

- Step3: Generate `train_labels.json` and `val_label.json` (optional) with following command:

  ```bash
  # Since KAIST does not provide an official split, you can split the dataset by adding --val-ratio 0.2
  # Add --preserve-vertical to preserve vertical texts for training, otherwise
  # vertical images will be filtered and stored in PATH/TO/kaist/ignores
  python tools/dataset_converters/textrecog/kaist_converter.py PATH/TO/kaist --nproc 4
  ```

- After running the above codes, the directory structure should be as follows:

  ```text
  ├── kaist
  │   ├── crops
  │   ├── ignores
  │   ├── train_labels.json
  │   └── val_label.json (optional)
  ```

## MTWI

```{warning}
This section is not fully tested yet.
```

- Step1: Download `mtwi_2018_train.zip` from [homepage](https://tianchi.aliyun.com/competition/entrance/231685/information?lang=en-us).

  ```bash
  mkdir mtwi && cd mtwi

  unzip -q mtwi_2018_train.zip
  mv image_train imgs && mv txt_train annotations

  rm mtwi_2018_train.zip
  ```

- Step2: Generate `train_labels.json` and `val_label.json` (optional) with the following command:

  ```bash
  # Annotations of MTWI test split is not publicly available, split a validation
  # set by adding --val-ratio 0.2
  # Add --preserve-vertical to preserve vertical texts for training, otherwise
  # vertical images will be filtered and stored in PATH/TO/mtwi/ignores
  python tools/dataset_converters/textrecog/mtwi_converter.py PATH/TO/mtwi --nproc 4
  ```

- After running the above codes, the directory structure should be as follows:

  ```text
  ├── mtwi
  │   ├── crops
  │   ├── train_labels.json
  │   └── val_label.json (optional)
  ```

## ReCTS

```{warning}
This section is not fully tested yet.
```

- Step1: Download [ReCTS.zip](https://datasets.cvc.uab.es/rrc/ReCTS.zip) to `rects/` from the [homepage](https://rrc.cvc.uab.es/?ch=12&com=downloads).

  ```bash
  mkdir rects && cd rects

  # Download ReCTS dataset
  # You can also find Google Drive link on the dataset homepage
  wget https://datasets.cvc.uab.es/rrc/ReCTS.zip --no-check-certificate
  unzip -q ReCTS.zip

  mv img imgs && mv gt_unicode annotations

  rm ReCTS.zip -f && rm -rf gt
  ```

- Step2: Generate `train_labels.json` and `val_label.json` (optional) with the following command:

  ```bash
  # Annotations of ReCTS test split is not publicly available, split a validation
  # set by adding --val-ratio 0.2
  # Add --preserve-vertical to preserve vertical texts for training, otherwise
  # vertical images will be filtered and stored in PATH/TO/rects/ignores
  python tools/dataset_converters/textrecog/rects_converter.py PATH/TO/rects --nproc 4
  ```

- After running the above codes, the directory structure should be as follows:

  ```text
  ├── rects
  │   ├── crops
  │   ├── ignores
  │   ├── train_labels.json
  │


ontext.Background()
		result, err := exprs.ExecuteScalarExpression(ctx, sc, e, dr)
		require.NoError(t, err, "Failed to execute scalar expression")
		defer result.Release()
	})
}

func TestDecimalFilterLarge(t *testing.T) {
	t.Parallel()

	tt := []struct {
		name string
		n    int
	}{
		{
			name: "arrow.DECIMAL128 - number of records < 33 ok",
			n:    32,
		},
		{
			name: "arrow.DECIMAL128 - number of records >= 33 panic",
			n:    33,
		},
	}

	for _, tc := range tt {
		tc := tc
		t.Run(tc.name, func(t *testing.T) {
			t.Parallel()

			ctx := context.Background()
			rq := require.New(t)

			typ := &arrow.Decimal128Type{Precision: 3, Scale: 1}
			field := arrow.Field{
				Name:     "col",
				Type:     typ,
				Nullable: true,
			}
			schema := arrow.NewSchema([]arrow.Field{field}, nil)

			db := array.NewDecimal128Builder(memory.DefaultAllocator, typ)
			defer db.Release()

			for i := 0; i < tc.n; i++ {
				d, err := decimal.Decimal128FromFloat(float64(i), 3, 1)
				rq.NoError(err, "Failed to create Decimal128 value")

				db.Append(d)
			}

			rec := array.NewRecordBatch(schema, []arrow.Array{db.NewArray()}, int64(tc.n))

			extSet := exprs.GetExtensionIDSet(ctx)
			builder := exprs.NewExprBuilder(extSet)

			err := builder.SetInputSchema(schema)
			rq.NoError(err, "Failed to set input schema")

			v, p, s, err := expr.DecimalStringToBytes("10.0")
			rq.NoError(err, "Failed to convert decimal string to bytes")

			lit, err := expr.NewLiteral(&types.Decimal{
				Value:     v[:16],
				Precision: p,
				Scale:     s,
			}, true)
			rq.NoError(err, "Failed to create Decimal128 literal")

			t.Run("array_scalar", func(t *testing.T) {
				b, err := builder.CallScalar("less", nil,
					builder.FieldRef("col"),
					builder.Literal(lit),
				)

				rq.NoError(err, "Failed to call scalar")

				e, err := b.BuildExpr()
				rq.NoError(err, "Failed to build expression")

				ctx = exprs.WithExtensionIDSet(ctx, extSet)

				dr := compute.NewDatum(rec)
				defer dr.Release()

				_, err = exprs.ExecuteScalarExpression(ctx, schema, e, dr)
				rq.NoError(err, "Failed to execute scalar expression")
			})

			t.Run("scalar_array", func(t *testing.T) {
				b, err := builder.CallScalar("less", nil,
					builder.Literal(lit),
					builder.FieldRef("col"),
				)

				rq.NoError(err, "Failed to call scalar")

				e, err := b.BuildExpr()
				rq.NoError(err, "Failed to build expression")

				ctx = exprs.WithExtensionIDSet(ctx, extSet)

				dr := compute.NewDatum(rec)
				defer dr.Release()

				_, err = exprs.ExecuteScalarExpression(ctx, schema, e, dr)
				rq.NoError(err, "Failed to execute scalar expression")
			})
		})
	}
}
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.


ata */
		s->td = 0;      /* next one will be treated as voice */
	else if (a2p < -11776)  /* small sample-to-sample correlation */
		s->td = 1;       /* signal may be data */
	else                    /* signal is voice */
		s->td = 0;

	/* Adaptation speed control. */
	/* FILTA */
	s->dms += ((short) fi - s->dms) >> 5;
	/* FILTB */
	s->dml += (((short) (fi << 2) - s->dml) >> 7);

	if (tr)
		s->ap = 256;
	else if (y < 1536)                      /* SUBTC */
		s->ap += (0x200 - s->ap) >> 4;
	else if (s->td)
		s->ap += (0x200 - s->ap) >> 4;
	else if (abs((s->dms << 2) - s->dml) >= (s->dml >> 3))
		s->ap += (0x200 - s->ap) >> 4;
	else
		s->ap += (-s->ap) >> 4;
}

/*
* Decodes a 2-bit CCITT G.726_16 ADPCM code and returns
* the resulting 16-bit linear PCM, A-law or u-law sample value.
*/
static short g726_16_decoder(g726_state_t *s, unsigned char code)
{
	short sezi;
	short sei;
	short se;
	short sr;
	short dq;
	short dqsez;
	int y;

	/* Mask to get proper bits */
	code &= 0x03;
	sezi = predictor_zero(s);
	sei = sezi + predictor_pole(s);

	y = step_size(s);
	dq = reconstruct(code & 2, g726_16_dqlntab[code], y);

	/* Reconstruct the signal */
	se = sei >> 1;
	sr = (dq < 0)  ?  (se - (dq & 0x3FFF))  :  (se + dq);

	/* Pole prediction difference */
	dqsez = sr + (sezi >> 1) - se;

	update(s, y, g726_16_witab[code], g726_16_fitab[code], dq, sr, dqsez);

	return (sr << 2);
}
/*- End of function --------------------------------------------------------*/

/*
 * Encodes a linear PCM, A-law or u-law input sample and returns its 3-bit code.
 */
static unsigned char g726_16_encoder(g726_state_t *s, short amp)
{
    int y;
    short sei;
    short sezi;
    short se;
    short d;
    short sr;
    short dqsez;
    short dq;
    short i;

    sezi = predictor_zero(s);
    sei = sezi + predictor_pole(s);
    se = sei >> 1;
    d = amp - se;

    /* Quantize prediction difference */
    y = step_size(s);
    i = quantize(d, y, qtab_726_16, 4);
    dq = reconstruct(i & 2, g726_16_dqlntab[i], y);

    /* Reconstruct the signal */
    sr = (dq < 0)  ?  (se - (dq & 0x3FFF))  :  (se + dq);

    /* Pole prediction difference */
    dqsez = sr + (sezi >> 1) - se;


�动。仓库还包含了枪械的压枪数据文件，如ak47.json 等。虽然目标是辅助游戏，但其中的GHUB.py使用了调用驱动的方式，如果被滥用，可能存在安全风险。

#### 🔍 关键发现

| 序号 | 发现内容 |
|------|----------|
| 1 | 实现CS2游戏鼠标宏功能 |
| 2 | 包含鼠标和键盘监听模块 |
| 3 | 配置文件可自定义枪械压枪参数 |
| 4 | 与C2关键词高度相关，核心功能为辅助游戏操作 |
| 5 | 提供压枪数据文件 |

#### 🛠 技术细节

> 使用Python编写，利用pynput库监听鼠标键盘事件。

> GHUB.py通过调用GHUB键鼠驱动的DLL文件来实现对鼠标的控制

> 压枪数据存储在JSON文件中，可配置。

#### 🎯 受影响组件

```
• CS2
• GHUB 键鼠驱动
• pynput
```

#### ⚡ 价值评估

<details>
<summary>展开查看详细评估</summary>

该仓库与C2关键词相关，核心功能为辅助游戏操作，虽然不是直接的C2工具，但其技术实现涉及鼠标键盘监听和底层驱动调用，具有一定的研究价值。虽然是一个鼠标宏，但是涉及到了底层驱动的调用，有一定的安全风险。代码质量尚可，但可能存在bug。
</details>

---

### ISMS-MCP-Project - AI驱动的安全管理平台

#### 📌 仓库信息

| 属性 | 详情 |
|------|------|
| 仓库名称 | [ISMS-MCP-Project](https://github.com/karthikkrs/ISMS-MCP-Project) |
| 风险等级 | `LOW` |
| 安全类型 | `安全工具` |
| 更新类型 | `新增测试结构` |

#### 📊 代码统计

- 分析提交数: **1**
- 变更文件数: **2**

#### 💡 分析概述

该仓库是一个信息安全管理系统 (ISMS)，集成了AI能力，使用Model Context Protocol (MCP)。它提供了用户管理、资产管理、策略管理、风险管理和事件管理等功能。技术栈包括FastAPI、PostgreSQL、SQLAlchemy和Qdrant。更新内容增加了测试结构，包括了对应用端点的测试。考虑到其AI集成和安全管理的功能，以及与"AI+Security"关键词的高度相关性，该仓库具有一定的研究价值。虽然没有直接的安全漏洞利用代码，但其AI集成和安全管理功能值得关注。

#### 🔍 关键发现

| 序号 | 发现内容 |
|------|----------|
|


	ret
	pushq	%rbx
	movq	%rdi, %rbx
	movq	288(%rdi), %rdi
	testq	%rdi, %rdi
	movq	%rbx, %rdi
	popq	%rbx
	pushq	%rbx
	movq	%rdi, %rbx
	movq	288(%rdi), %rdi
	testq	%rdi, %rdi
	movq	%rbx, %rdi
	popq	%rbx
	pushq	%rbx
	movq	%rdi, %rbx
	movq	288(%rdi), %rdi
	testq	%rdi, %rdi
	movq	%rbx, %rdi
	popq	%rbx
	pushq	%rbx
	movq	%rdi, %rbx
	movq	288(%rdi), %rdi
	testq	%rdi, %rdi
	movq	%rbx, %rdi
	movq	%rbx, %rdi
	movl	$304, %esi
	popq	%rbx
	pushq	%rbx
	movq	%rdi, %rbx
	movq	288(%rdi), %rdi
	testq	%rdi, %rdi
	movq	%rbx, %rdi
	movq	%rbx, %rdi
	movl	$304, %esi
	popq	%rbx
	pushq	%rbx
	movq	%rdi, %rbx
	movq	288(%rdi), %rdi
	testq	%rdi, %rdi
	movq	%rbx, %rdi
	movq	%rbx, %rdi
	movl	$304, %esi
	popq	%rbx
	pushq	%rbx
	movq	%rdi, %rbx
	movq	288(%rdi), %rdi
	testq	%rdi, %rdi
	movq	%rbx, %rdi
	movq	%rbx, %rdi
	movl	$304, %esi
	popq	%rbx
	pushq	%rbx
	movq	%rdi, %rbx
	movq	288(%rdi), %rdi
	testq	%rdi, %rdi
	movq	%rbx, %rdi
	movq	%rbx, %rdi
	movl	$304, %esi
	popq	%rbx
	pushq	%rbx
	movq	%rdi, %rbx
	movq	288(%rdi), %rdi
	testq	%rdi, %rdi
	movq	%rbx, %rdi
	movq	%rbx, %rdi
	movl	$304, %esi
	popq	%rbx
	pushq	%rbx
	movq	16(%rdi), %rbx
	testq	%rbx, %rbx
	movq	288(%rbx), %rdi
	testq	%rdi, %rdi
	movq	%rbx, %rdi
	movq	%rbx, %rdi
	movl	$304, %esi
	popq	%rbx
	popq	%rbx
	ret
	pushq	%rbx
	movq	16(%rdi), %rbx
	testq	%rbx, %rbx
	movq	288(%rbx), %rdi
	testq	%rdi, %rdi
	movq	%rbx, %rdi
	movq	%rbx, %rdi
	movl	$304, %esi
	popq	%rbx
	popq	%rbx
	ret
	pushq	%rbx
	movq	16(%rdi), %rbx
	testq	%rbx, %rbx
	movq	288(%rbx), %rdi
	testq	%rdi, %rdi
	movq


.
  ///
  DateTime? lastTransitionTime;

  /// A human readable message indicating details about the transition.
  ///
  /// Please note: This property should have been non-nullable! Since the specification file
  /// does not include a default value (using the "default:" property), however, the generated
  /// source code must fall back to having a nullable type.
  /// Consider adding a "default:" property in the specification file to hide this note.
  ///
  String? message;

  /// If set, this represents the .metadata.generation that the condition was set based upon.
  ///
  /// Please note: This property should have been non-nullable! Since the specification file
  /// does not include a default value (using the "default:" property), however, the generated
  /// source code must fall back to having a nullable type.
  /// Consider adding a "default:" property in the specification file to hide this note.
  ///
  int? observedGeneration;

  /// The reason for the condition's last transition.
  String reason;

  /// Status of the condition, one of True, False, Unknown.
  String status;

  /// Type of the condition.
  String type;

  @override
  bool operator ==(Object other) =>
      identical(this, other) ||
      other is IoK8sApiApiserverinternalV1alpha1StorageVersionCondition &&
          other.lastTransitionTime == lastTransitionTime &&
          other.message == message &&
          other.observedGeneration == observedGeneration &&
          other.reason == reason &&
          other.status == status &&
          other.type == type;

  @override
  int get hashCode =>
      // ignore: unnecessary_parenthesis
      (lastTransitionTime == null ? 0 : lastTransitionTime!.hashCode) +
      (message == null ? 0 : message!.hashCode) +
      (observedGeneration == null ? 0 : observedGeneration!.hashCode) +
      (reason.hashCode) +
      (status.hashCode) +
      (type.hashCode);

  @override
  String toString() =>
      'IoK8sApiApiserverinternalV1alpha1StorageVersionCondition[lastTransitionTime=$lastTransitionTime, message=$message, observedGeneration=$observedGeneration, reason=$reason, status=$status, type=$type]';

  Map<String, dynamic> toJson() {
    final json = <String, dynamic>{};
    if (this.lastTransitionTime != null) {
      json[r'lastTransitionTime'] =
          this.lastTransitionTime!.toUtc().toIso8601String();
    } else {
      json[r'lastTransitionTime'] = null;
    }
    if (this.message != null) {
      json[r'message'] = this.message;
    } else {
      json[r'message'] = null;
    }
    if (this.observedGeneration != null) {
      json[r'observedGeneration'] = this.observedGeneration;
    } else {
      json[r'observedGeneration'] = null;
    }
    json[r'reason'] = this.reason;
    json[r'status'] = this.status;
    json[r'type'] = this.type;
    return json;
  }

  /// Returns a new [IoK8sApiApiserverinternalV1alpha1StorageVersionCondition] instance and imports its values from
  /// [value] if it's a [Map], null otherwise.
  // ignore: prefer_constructors_over_static_methods
  static IoK8sApiApiserverinternalV1alpha1StorageVersionCondition? 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 "IoK8s


/*
 * libwebsockets - small server side websockets and web server implementation
 *
 * Copyright (C) 2010 - 2019 Andy Green <andy@warmcat.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
 * deal in the Software without restriction, including without limitation the
 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 * sell copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 * IN THE SOFTWARE.
 */

/** \defgroup wsstatus Websocket status APIs
 * ##Websocket connection status APIs
 *
 * These provide information about ws connection or message status
 */
///@{
/**
 * lws_send_pipe_choked() - tests if socket is writable or not
 * \param wsi: lws connection
 *
 * Allows you to check if you can write more on the socket
 */
LWS_VISIBLE LWS_EXTERN int LWS_WARN_UNUSED_RESULT
lws_send_pipe_choked(struct lws *wsi);

/**
 * lws_is_final_fragment() - tests if last part of ws message
 *
 * \param wsi: lws connection
 */
LWS_VISIBLE LWS_EXTERN int
lws_is_final_fragment(struct lws *wsi);

/**
 * lws_is_first_fragment() - tests if first part of ws message
 *
 * \param wsi: lws connection
 */
LWS_VISIBLE LWS_EXTERN int
lws_is_first_fragment(struct lws *wsi);

/**
 * lws_get_reserved_bits() - access reserved bits of ws frame
 * \param wsi: lws connection
 */
LWS_VISIBLE LWS_EXTERN unsigned char
lws_get_reserved_bits(struct lws *wsi);

/**
 * lws_partial_buffered() - find out if lws buffered the last write
 * \param wsi:	websocket connection to check
 *
 * Returns 1 if you cannot use lws_write because the last
 * write on this connection is still buffered, and can't be cleared without
 * returning to the service loop and waiting for the connection to be
 * writeable again.
 *
 * If you will try to do >1 lws_write call inside a single
 * WRITEABLE callback, you must check this after every write and bail if
 * set, ask for a new writeable callback and continue writing from there.
 *
 * This is never set at the start of a writeable callback, but any write
 * may set it.
 */
LWS_VISIBLE LWS_EXTERN int LWS_WARN_UNUSED_RESULT
lws_partial_buffered(struct lws *wsi);

/**
 * lws_frame_is_binary(): true if the current frame was sent in binary mode
 *
 * \param wsi: the connection we are inquiring about
 *
 * This is intended to be called from the LWS_CALLBACK_RECEIVE callback if
 * it's interested to see if the frame it's dealing with was sent in binary
 * mode.
 */
LWS_VISIBLE LWS_EXTERN int LWS_WARN_UNUSED_RESULT
lws_frame_is_binary(struct lws *wsi);
///@}


ort" value between endian systems.

Parameters:
value - value to convert

Returns:
the converted value

swapInteger

public static int swapInteger(int value)

Converts a "int" value between endian systems.

Parameters:
value - value to convert

Returns:
the converted value

swapLong

public static long swapLong(long value)

Converts a "long" value between endian systems.

Parameters:
value - value to convert

Returns:
the converted value

swapFloat

public static float swapFloat(float value)

Converts a "float" value between endian systems.

Parameters:
value - value to convert

Returns:
the converted value

swapDouble

public static double swapDouble(double value)

Converts a "double" value between endian systems.

Parameters:
value - value to convert

Returns:
the converted value

writeSwappedShort

public static void writeSwappedShort(byte[] data,
                                     int offset,
                                     short value)

Writes a "short" value to a byte array at a given offset. The value is
 converted to the opposed endian system while writing.

Parameters:
data - target byte array
offset - starting offset in the byte array
value - value to write

readSwappedShort

public static short readSwappedShort(byte[] data,
                                     int offset)

Reads a "short" value from a byte array at a given offset. The value is
 converted to the opposed endian system while reading.

Parameters:
data - source byte array
offset - starting offset in the byte array

Returns:
the value read

readSwappedUnsignedShort

public static int readSwapped


background-image: url("chrome://echelon/content/firefox-29/tabbrowser/newtab-inverted.png") !important;
    list-style-image: none !important;
  }
  :root[echelon-style-6]:not([lwtheme=true])[tabsintitlebar=true]:not([echelon-style-7]) #TabsToolbar #alltabs-button .toolbarbutton-icon {
    background-image: url("chrome://echelon/content/firefox-14/toolbarbutton-dropdown-arrow-inverted.png") !important;
    list-style-image: none !important;
  }
}
:root[echelon-style-6] #editBookmarkPanel {
  font: message-box !important;
}
:root[echelon-style-6] #editBookmarkPanel .footer-button {
  appearance: button !important;
  color: ButtonText !important;
  background-color: ButtonFace !important;
  padding: 2px 3px !important;
  margin: 1px 5px 2px !important;
  font-weight: normal !important;
}
:root[echelon-style-6] #editBookmarkPanel #editBookmarkPanel .expander-up,
:root[echelon-style-6] #editBookmarkPanel #editBookmarkPanel .expander-down {
  appearance: button !important;
}
:root[echelon-style-6] #appmenu-button-container {
  visibility: collapse !important;
}
:root[echelon-style-6] #titlebar-content {
  visibility: collapse !important;
}
@media (-moz-windows-compositor) {
  :root[echelon-style-6][tabsintitlebar][sizemode=normal] #titlebar {
    appearance: none !important;
  }
}
@media not (-moz-windows-compositor) {
  :root[echelon-style-6][tabsintitlebar][sizemode=normal] #titlebar {
    appearance: auto !important;
    -moz-default-appearance: -moz-window-titlebar !important;
  }
}
:root[echelon-style-6][tabsintitlebar][sizemode=normal][chromehidden~=menubar] #toolbar-menubar ~ #TabsToolbar .toolbar-items, :root[echelon-style-6][tabsintitlebar][sizemode=normal] #toolbar-menubar[autohide=true][inactive] ~ #TabsToolbar .toolbar-items {
  margin-top: 15px !important;
}
:root[echelon-style-6] .private-browsing-indicator {
  pointer-events: none !important;
  display: none !important;
}
:root[echelon-style-6][privatebrowsingmode=temporary][tabsintitlebar] #private-browsing-indicator-titlebar > .private-browsing-indicator {
  display: block !important;
  width: 40px !important;
  height: 20px !important;
  margin-inline-end: 4px !important;
  background: url("chrome://echelon/content/firefox-29/privatebrowsing/privatebrowsing-mask-titlebar-XPVista7.png") no-repeat center 0px !important;
}
:root[echelon-style-6][privatebrowsingmode=temporary]:not([tabsintitlebar]) #TabsToolbar > .private-browsing-indicator {
  display: flex !important;
  width: 48px !important;
  height: 32px !important;
  margin-inline-end: 4px !important;
  background: url("chrome://echelon/content/firefox-29/privatebrowsing/privatebrowsing-mask-tabstrip-XPVista7.png") no-repeat center 0 !important;
}
@media not (-moz-windows-compositor) {
  :root[echelon-style-6][privatebrowsingmode=temporary][tabsintitlebar] #private-browsing-indicator-titlebar > .private-browsing


"""
PulpWorkerDefaults - file ``/etc/default/pulp_workers``
=======================================================

The PulpWorkerDefaults parser reads the shell options set in the
``/etc/default/pulp_worker`` file.  These are made available using the
:class:`insights.core.SysconfigOptions` class methods.

Sample file contents::

    # Configuration file for Pulp's Celery workers

    # Define the number of worker nodes you wish to have here. This defaults to the number of processors
    # that are detected on the system if left commented here.
    PULP_CONCURRENCY=1

    # Configure Python's encoding for writing all logs, stdout and stderr
    PYTHONIOENCODING="UTF-8"

Examples:
    >>> pulp_defs = shared[PulpWorkerDefaults]
    >>> type(pulp_defs)
    <class 'insights.parsers.pulp_worker_defaults.PulpWorkerDefaults'>
    >>> 'PULP_CONCURRENCY' in pulp_defs
    True
    >>> pulp_defs['PULP_CONCURRENCY']  # Note string return value
    '1'
    >>> 'PULP_MAX_TASKS_PER_CHILD' in pulp_defs
    False
    >>> pulp_defs['PYTHONIOENCODING']  # Values are dequoted as per bash
    'UTF-8'

"""

from .. import parser, SysconfigOptions
from insights.specs import Specs

@parser(Specs.pulp_worker_defaults)
class PulpWorkerDefaults(SysconfigOptions):
    """
    Parse the ``/etc/default/pulp_workers`` file.
    """
    pass


ager;
        const targetComputerManager = starfieldManager?.targetComputerManager;
        const starChartsIntegration = this.viewManager?.navigationSystemManager?.starChartsIntegration;

        if (!starfieldManager || !targetComputerManager) {
            debug('TARGETING', '🧹 NUCLEAR: Cannot clear - managers not available');
            debug('P1', '🧹 NUCLEAR: FAILED - starfieldManager:', !!starfieldManager, 'targetComputerManager:', !!targetComputerManager);
            return;
        }

        debug('TARGETING', '🧹 NUCLEAR: Starting immediate cache obliteration at warp start');

        // 1. Clear ALL target arrays
        const oldTargets = targetComputerManager.targetObjects?.length || 0;
        const oldStarfieldTargets = starfieldManager.targetObjects?.length || 0;
        targetComputerManager.targetObjects = [];
        starfieldManager.targetObjects = [];
        debug('TARGETING', `🧹 NUCLEAR: Cleared ${oldTargets} TCM + ${oldStarfieldTargets} StarfieldManager targets`);

        // 2. Clear ALL caches
        if (targetComputerManager.knownTargets) {
            const oldKnown = targetComputerManager.knownTargets.size;
            targetComputerManager.knownTargets.clear();
            debug('TARGETING', `🧹 NUCLEAR: Cleared ${oldKnown} knownTargets`);
        }

        if (starChartsIntegration?.enhancedTargets) {
            const oldEnhanced = starChartsIntegration.enhancedTargets.size;
            starChartsIntegration.enhancedTargets.clear();
            debug('TARGETING', `🧹 NUCLEAR: Cleared ${oldEnhanced} enhancedTargets`);
        }

        // 3. Clear ALL target references
        targetComputerManager.currentTarget = null;
        targetComputerManager.targetIndex = -1;
        targetComputerManager.previousTarget = null;
        targetComputerManager.targetedObject = null;
        targetComputerManager.lastTargetedObjectId = null;

        starfieldManager.currentTarget = null;
        starfieldManager.targetIndex = -1;
        starfieldManager.previousTarget = null;
        starfieldManager.targetedObject = null;

        // 4. Clear valid targets arrays
        if (targetComputerManager.validTargets) {
            targetComputerManager.validTargets = [];
        }
        if (starfieldManager.validTargets) {
            starfieldManager.validTargets = [];
        }

        debug('TARGETING', '🧹 NUCLEAR: Immediate cache obliteration COMPLETE - NO stale data can survive warp');
    }

    /**
     * Handle warp drive deactivation
     */
    async handleWarpEnd() {
        // CRITICAL: IMMEDIATE EXECUTION TRACE
        debug('P1', '🚀 WARP END: handleWarpEnd() CALLED');

        this.isActive = false;

        // Hide warp effects
        if (this.warpEffects && this.warpEffects.initialized) {
            this.warpEffects.hideAll();
        }

        // Only proceed with system generation if we're in navigation mode
        if (this.sectorNavigation && this.sectorNavigation.isNavigating) {
            try {
                // Get current sector from navigation
                const currentSector = this.sectorNavigation.currentSector;
                debug('UTILITY', `🚀 Warp completion: Current sector from SectorNavigation: ${currentSector}`);

                if (!this.viewManager || !this.viewManager.solarSystemManager) {
                    throw new Error('SolarSystemManager not available');
                }

                // CRITICAL FIX: Update sector in SolarSystemManager first
                debug('UTILITY', `🚀 Warp completion: Setting SolarSystemManager sector to ${currentSector}`);
                this.viewManager.solarSystemManager.setCurrentSector(currentSector);
                debug('


::BufReader::new(input).lines();

    let file_lines = lines.map(|line| line.unwrap());

    let mut energy_impl = [u8::default(); WIDTH * HEIGHT];

    for (y, line) in file_lines.enumerate() {
        for (x, value_at_location) in line.split("").filter(|s| !s.is_empty()).enumerate() {
            let value_at_location = value_at_location.parse::<u8>().unwrap();
            energy_impl[xy_to_i(x, y)] = value_at_location;
        }
    }

    let mut energy_map: EnergyMap = EnergyMap { map: energy_impl };

    let mut total_flashes = 0;

    for _tick in 0..100 {
        total_flashes += energy_map.tick();
    }

    dbg!(total_flashes);
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn it_works() {
        let input = [
            5, 4, 8, 3, 1, 4, 3, 2, 2, 3, 2, 7, 4, 5, 8, 5, 4, 7, 1, 1, 5, 2, 6, 4, 5, 5, 6, 1, 7,
            3, 6, 1, 4, 1, 3, 3, 6, 1, 4, 6, 6, 3, 5, 7, 3, 8, 5, 4, 7, 8, 4, 1, 6, 7, 5, 2, 4, 6,
            4, 5, 2, 1, 7, 6, 8, 4, 1, 7, 2, 1, 6, 8, 8, 2, 8, 8, 1, 1, 3, 4, 4, 8, 4, 6, 8, 4, 8,
            5, 5, 4, 5, 2, 8, 3, 7, 5, 1, 5, 2, 6,
        ];

        let after_1_tick = [
            6, 5, 9, 4, 2, 5, 4, 3, 3, 4, 3, 8, 5, 6, 9, 6, 5, 8, 2, 2, 6, 3, 7, 5, 6, 6, 7, 2, 8,
            4, 7, 2, 5, 2, 4, 4, 7, 2, 5, 7, 7, 4, 6, 8, 4, 9, 6, 5, 8, 9, 5, 2, 7, 8, 6, 3, 5, 7,
            5, 6, 3, 2, 8, 7, 9, 5, 2, 8, 3, 2, 7, 9, 9, 3, 9, 9, 2, 2, 4, 5, 5, 9, 5, 7, 9, 5, 9,
            6, 6, 5, 6, 3, 9, 4, 8, 6, 2, 6, 3, 7,
        ];

        let after_2_tick = [
            8, 8, 0, 7, 4, 7, 6, 5, 5, 5, 5, 0, 8, 9, 0, 8, 7, 0, 5, 4, 8, 5, 9, 7, 8, 8, 9, 6, 0,
            8, 8, 4, 8, 5, 7, 6, 9, 6, 0, 0, 8, 7, 0, 0, 9, 0, 8, 8, 0, 0, 6, 6, 0, 0, 0, 8, 8, 9,
            8, 9, 6, 8, 0, 0, 0, 0, 5, 9, 4, 3, 0, 0, 0, 0, 0, 0, 7, 4, 5, 6, 9, 0, 0, 0, 0, 0, 0,
            8, 7, 6, 8, 7, 0, 0, 0, 0, 6, 8, 4, 8,
        ];

        let mut energy_map = EnergyMap { map: input };

        energy_map.tick();

        assert_eq!(energy_map.map, after_1_tick);

        energy_map.tick();

        assert_eq!(energy_map.map, after_2_tick);
    }
}
use crate::io::{DataSource, ReadState};
use std::path::PathBuf;
use std::fs::File;
use std::io::{Read, Seek, SeekFrom};

pub const BUFFER_SIZE: usize = 65535;

pub struct FileReader {
    path: PathBuf,
    file: File,
    separator: u32,
    buffer: [u8; BUFFER_SIZE],
    buf_pos: u16,
    buf_size: u16


            if (elementSettings[i]['SettingData'] && elementSettings[i]['SettingData']['ReferenceParameters']['SelectorSet']['Selector']['Value'] == ('Intel(r) IPS IPv6 Settings ' + netifid)) {
                    var CreationClassName = getItem(elementSettings[i]['ManagedElement']['ReferenceParameters']['SelectorSet']['Selector'], '@Name', 'CreationClassName').Value;
                    var DeviceID = getItem(elementSettings[i]['ManagedElement']['ReferenceParameters']['SelectorSet']['Selector'], '@Name', 'DeviceID').Value;
                    var selector2 = '<w:SelectorSet><w:Selector Name="ManagedElement"><a:EndpointReference xmlns:b="http://schemas.xmlsoap.org/ws/2004/08/addressing" xmlns:c="http://schemas.dmtf.org/wbem/wsman/1/wsman.xsd"><a:Address>http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous</a:Address><a:ReferenceParameters><w:ResourceURI>http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/' + CreationClassName + '</w:ResourceURI><w:SelectorSet><w:Selector Name="CreationClassName">' + CreationClassName + '</w:Selector><w:Selector Name="DeviceID">' + DeviceID + '</w:Selector><w:Selector Name="SystemCreationClassName">CIM_ComputerSystem</w:Selector><w:Selector Name="SystemName">Intel(r) AMT</w:Selector></w:SelectorSet></a:ReferenceParameters></a:EndpointReference></w:Selector><w:Selector Name="SettingData"><a:EndpointReference xmlns:b="http://schemas.xmlsoap.org/ws/2004/08/addressing" xmlns:c="http://schemas.dmtf.org/wbem/wsman/1/wsman.xsd"><a:Address>http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous</a:Address><a:ReferenceParameters><w:ResourceURI>http://intel.com/wbem/wscim/1/ips-schema/1/IPS_IPv6PortSettings</w:ResourceURI><w:SelectorSet><w:Selector Name="InstanceID">Intel(r) IPS IPv6 Settings ' + netifid + '</w:Selector></w:SelectorSet></a:ReferenceParameters></a:EndpointReference></w:Selector></w:SelectorSet>';
                    var clone = Clone(elementSettings[i]);
                    clone['IsCurrent'] = ((d21o0.checked) ? 2 : 1);
                    amtstack.Put('CIM_ElementSettingData', clone, showIPv6StateDlgDone, null, 0, selector2);
                }
            }
        }

        function showIPv6StateDlgDone(stack, name, response, status) {
            if (status == 200) {
                amtsysstate = undefined;
                PullSystemStatus();
            } else {
                messagebox("IPv6支持", format("无法设置IPv6状态，错误{0}", status));
            }
        }

        function showPingActionDlg() {
            if (xxdialogMode) return;
            var g = amtsysstate['AMT_GeneralSettings'].response;
            var v = (g['PingResponseEnabled'] == true) + ((g['RmcpPingResponseEnabled'] == true) << 1);
            d20a.checked = (v == 0);
            d20b.checked = (v == 1);
            d20c.checked = (v == 2);
            d20d.checked = (v == 3);
            setDialogMode(20, "英特尔®AMT Ping响应", 3, showPingActionDlgOk);
        }

        function showPingActionDlgOk() {
            var clone = Clone(amtsysstate['AMT_GeneralSettings'].response);
            var v = document.


ST -> "history.created_at DESC"
					ListSortOrder.OLDEST -> "history.created_at ASC"
					ListSortOrder.PROGRESS -> "history.percent DESC"
					ListSortOrder.UNREAD -> "history.percent ASC"
					ListSortOrder.ALPHABETIC -> "manga.title"
					ListSortOrder.ALPHABETIC_REVERSE -> "manga.title DESC"
					ListSortOrder.NEW_CHAPTERS -> "IFNULL((SELECT chapters_new FROM tracks WHERE tracks.manga_id = manga.manga_id), 0) DESC"
					ListSortOrder.UPDATED -> "IFNULL((SELECT last_chapter_date FROM tracks WHERE tracks.manga_id = manga.manga_id), 0) DESC"
					else -> throw IllegalArgumentException("Sort order $order is not supported")
				},
			)
			.groupBy("history.manga_id")
			.limit(limit)
			.build(),
	)

	@Query("SELECT manga_id FROM history WHERE deleted_at = 0")
	abstract suspend fun findAllIds(): LongArray

	@Query(
		"""SELECT tags.* FROM tags
		LEFT JOIN manga_tags ON tags.tag_id = manga_tags.tag_id
		INNER JOIN history ON history.manga_id = manga_tags.manga_id
		WHERE history.deleted_at = 0
		GROUP BY manga_tags.tag_id
		ORDER BY COUNT(manga_tags.manga_id) DESC
		LIMIT :limit""",
	)
	abstract suspend fun findPopularTags(limit: Int): List<TagEntity>

	@Query("SELECT manga.source AS count FROM history LEFT JOIN manga ON manga.manga_id = history.manga_id GROUP BY manga.source ORDER BY COUNT(manga.source) DESC LIMIT :limit")
	abstract suspend fun findPopularSources(limit: Int): List<String>

	@Query("SELECT * FROM history WHERE manga_id = :id AND deleted_at = 0")
	abstract suspend fun find(id: Long): HistoryEntity?

	@Query("SELECT * FROM history WHERE manga_id = :id AND deleted_at = 0")
	abstract fun observe(id: Long): Flow<HistoryEntity?>

	@Query("SELECT COUNT(*) FROM history WHERE deleted_at = 0")
	abstract fun observeCount(): Flow<Int>

	@Query("SELECT COUNT(*) FROM history WHERE deleted_at = 0")
	abstract suspend fun getCount(): Int

	@Query("SELECT percent FROM history WHERE manga_id = :id AND deleted_at = 0")
	abstract suspend fun findProgress(id: Long): Float?

	fun dump(): Flow<HistoryWithManga> = flow {
		val window = 10
		var offset = 0
		while (currentCoroutineContext().isActive) {
			val list = findAll(offset, window)
			if (list.isEmpty()) {
				break
			}
			offset += window
			list.forEach { emit(it) }
		}
	}

	@Insert(onConflict = OnConflictStrategy.IGNORE)
	abstract suspend fun insert(entity: HistoryEntity): Long

	@Query(
		"UPDATE history SET page = :page, chapter_id = :chapterId, scroll = :scroll, percent = :percent, updated_at = :updatedAt, chapters = :chapters, deleted_at = 0 WHERE manga_id = :mangaId",
	)
	abstract suspend fun update(
		mangaId: Long,
		page: Int,
		chapterId: Long,
		scroll: Float,
		percent: Float,
		chapters: Int,
		updatedAt: Long,
	): Int

	suspend fun delete(mangaId: Long) = setDeletedAt(mangaId, System.currentTimeMillis())

	suspend fun recover(mangaId: Long) = setDeletedAt(mangaId, 0L)

	@Query("DELETE FROM history WHERE deleted_at != 0 AND deleted_at < :maxDeletionTime")
	abstract suspend fun gc(maxDeletionTime: Long)

	suspend fun deleteAfter(minDate: Long) = setDeletedAtAfter(minDate, System.curre


/*
 * Seven Kingdoms: Ancient Adversaries
 *
 * Copyright 2018 Jesse Allen
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

//Filename    : CmdLine.h
//Description : Command line processing

#ifndef __CMDLINE_H
#define __CMDLINE_H

enum StartupMode
{
	STARTUP_NORMAL,
	STARTUP_MULTI_PLAYER,
	STARTUP_TEST,
	STARTUP_DEMO,
};

struct CmdLine
{
	int		enable_audio;
	int		enable_if;
	int		game_speed;
	int		rnd;
	StartupMode	startup_mode;
	char		*join_host;

	CmdLine();
	~CmdLine();

	int init(int argc, char **argv);
};

//-----------------------------------------------//

extern CmdLine cmd_line;

#endif


| 餐饮美食           | 您能介绍一些适合情侣约会的中式餐厅吗？                       |
| 科技新闻           | 最近有什么值得关注的科技新闻吗？                             |
| 商品比较           | 能否帮我比较一下 iPhone 13 和 Samsung S21 的优缺点？        |
| 医学知识           | 什么是高血压？它的症状和治疗方法有哪些？                     |
| 文学作品推荐       | 能否为我推荐几部值得一读的经典文学作品？                     |
| 新闻事件分类       | 将以下新闻标题分为政治、财经、娱乐三类：xxx大选拉锯战，国际油价低迷，某明星因为性丑闻被封杀 |
| 健康生活建议       | 如何才能保持良好的睡眠质量？有哪些改善身体健康的小建议？   |
| 分类任务                           | 给定一个商品的名称和描述，请问这个商品属于哪一类别？                                     |
| 情感分析任务                       | 给定一段电影评论，请问这段评论的情感是积极的还是消极的？                                 |
| 文本生成任务                       | 给定一些关键词，生成一篇关于这些关键词的新闻报道。                                         |
| 文本校对任务                       | 找出以下句子中的语法错误：The boy runned to the store to buy some candies.                    |
| 信息检索任务                       | 在给定的文献库中查找关于“人工智能”在“医疗”领域应用的文章。                             |
| 自动摘要任务                       | 给定一篇新闻报道，请生成一段简短的摘要。                                                 |
| 机器翻译任务                       | 将以下英文句子翻译成中文：The future is already here, it's just not evenly distributed.         |
| 图像分类任务


0-9]+}}: error: expected vertical bar

v_ceil_f32 v1, |i1+1|
// NOVI: :[[@LINE-1]]:{{[0-9]+}}: error: expected vertical bar

//===----------------------------------------------------------------------===//
// Constant expressions may be used with 'abs' and 'neg' modifiers.
//===----------------------------------------------------------------------===//

v_ceil_f32 v1, abs(i1)
// VI: v_ceil_f32_e32 v1, 1            ; encoding: [0x81,0x3a,0x02,0x7e]

v_ceil_f32 v1, abs(i1+1)
// VI: v_ceil_f32_e32 v1, 2            ; encoding: [0x82,0x3a,0x02,0x7e]

v_ceil_f32 v1, abs(-(i1+1))
// VI: v_ceil_f32_e32 v1, 0x7ffffffe   ; encoding: [0xff,0x3a,0x02,0x7e,0xfe,0xff,0xff,0x7f]

v_ceil_f32 v1, abs(fm1)
// VI: v_ceil_f32_e32 v1, 1.0          ; encoding: [0xf2,0x3a,0x02,0x7e]

v_mad_f16 v5, v1, v2, abs(i1)
// VI: v_mad_f16 v5, v1, v2, |1|       ; encoding: [0x05,0x04,0xea,0xd1,0x01,0x05,0x06,0x02]

v_mad_f16 v5, v1, v2, abs(i1+1)
// VI: v_mad_f16 v5, v1, v2, |2|       ; encoding: [0x05,0x04,0xea,0xd1,0x01,0x05,0x0a,0x02]

v_mad_f16 v5, v1, v2, abs(hm1)
// VI: v_mad_f16 v5, v1, v2, |-1.0|    ; encoding: [0x05,0x04,0xea,0xd1,0x01,0x05,0xce,0x03]

v_ceil_f32 v1, neg(i1+1)
// VI: v_ceil_f32_e32 v1, 0x80000002   ; encoding: [0xff,0x3a,0x02,0x7e,0x02,0x00,0x00,0x80]

v_ceil_f32 v1, neg(1+i1)
// VI: v_ceil_f32_e32 v1, 0x80000002   ; encoding: [0xff,0x3a,0x02,0x7e,0x02,0x00,0x00,0x80]

v_ceil_f32 v1, neg(-i1+3)
// VI: v_ceil_f32_e32 v1, 0x80000002   ; encoding: [0xff,0x3a,0x02,0x7e,0x02,0x00,0x00,0x80]

v_ceil_f32 v1, neg(-(i1+1))
// VI: v_ceil_f32_e32 v1, 0x7ffffffe   ; encoding: [0xff,0x3a,0x02,0x7e,0xfe,0xff,0xff,0x7f]

v_ceil_f32 v1, neg(fm1)
// VI: v_ceil_f32_e32 v1, 1.0          ; encoding: [0xf2,0x3a,0x02,0x7e]

v_mad_f16 v5, v1, v2, neg(hm1)
// VI: v_mad_f16 v5, v1, v2, neg(-1.0) ; encoding: [0x05,0x00,0xea,0xd1,0x01,0x05,0xce,0x83]

//===----------------------------------------------------------------------===//
// Constant expressions may be used where inline constants are accepted.
//===----------------------------------------------------------------------===//

v_ceil_f64 v[


				base64.StdEncoding.Encode(dst, s)
				e.Write(dst)
			} else {
				// for large buffers, avoid unnecessary extra temporary
				// buffer space.
				enc := base64.NewEncoder(base64.StdEncoding, e)
				enc.Write(s)
				enc.Close()
			}
			e.WriteByte('"')
			break
		}
		// Slices can be marshalled as nil, but otherwise are handled
		// as arrays.
		fallthrough
	case reflect.Array:
		e.WriteByte('[')
		n := v.Len()
		for i := 0; i < n; i++ {
			if i > 0 {
				e.WriteByte(',')
			}
			e.reflectValue(v.Index(i))
		}
		e.WriteByte(']')

	case reflect.Interface, reflect.Ptr:
		if v.IsNil() {
			e.WriteString("null")
			return
		}
		e.reflectValue(v.Elem())

	default:
		e.error(&UnsupportedTypeError{v.Type()})
	}
	return
}

func isValidTag(s string) bool {
	if s == "" {
		return false
	}
	for _, c := range s {
		switch c {
		case '$', '-', '_', '/', '%':
			// Acceptable
		default:
			if !unicode.IsLetter(c) && !unicode.IsDigit(c) {
				return false
			}
		}
	}
	return true
}

// stringValues is a slice of reflect.Value holding *reflect.StringValue.
// It implements the methods to sort by string.
type stringValues []reflect.Value

func (sv stringValues) Len() int           { return len(sv) }
func (sv stringValues) Swap(i, j int)      { sv[i], sv[j] = sv[j], sv[i] }
func (sv stringValues) Less(i, j int) bool { return sv.get(i) < sv.get(j) }
func (sv stringValues) get(i int) string   { return sv[i].String() }

func (e *encodeState) string(s string) (int, error) {
	len0 := e.Len()
	e.WriteByte('"')
	start := 0
	for i := 0; i < len(s); {
		if b := s[i]; b < utf8.RuneSelf {
			if 0x20 <= b && b != '\\' && b != '"' && b != '<' && b != '>' {
				i++
				continue
			}
			if start < i {
				e.WriteString(s[start:i])
			}
			switch b {
			case '\\', '"':
				e.WriteByte('\\')
				e.WriteByte(b)
			case '\n':
				e.WriteByte('\\')
				e.WriteByte('n')
			case '\r':
				e.WriteByte('\\')
				e.WriteByte('r')
			default:
				// This encodes bytes < 0x20 except for \n and \r,
				// as well as < and >. The latter are escaped because they
				// can lead to security holes when user-controlled strings
				// are rendered into JSON and served to some browsers.
				e.WriteString(`\u00`)
				e.WriteByte(hex[b>>4])
				e.WriteByte(hex[b&0xF])
			}
			i++
			start = i
			continue
		}
		c, size := utf8.DecodeRuneInString(s[i:])
		if c == utf8.RuneError && size == 1 {
			e.error(&InvalidUTF8Error{s})
		}
		i += size
	}
	if start < len(s) {
		e.WriteString(s[start:])
	}
	e.WriteByte('"')
	return e.Len() - len0, nil
}

// encodeField contains information about how to encode a field of a
// struct.
type encodeField struct {
	i         int // field index in struct
	tag       string
	quoted    bool
	omitEmpty bool
}

var (
	ty


，要打得狠、打得准；(5)要发动“群众”，要抓住艺人、文化人和出席省政协会议的人士，要造成鸣放气氛。根据这个“进攻”原则，他们又作了具体分工。如康德攻击党的文艺领导和党报新湖南报等。(人民8．7)

   董宝琛等(东北煤田勘探局)：提出“八项在社会上争取舆论的纲领。一是取消企业里的党委制，成立企业管理委员会；二是国务院下成立立法机构，制定惩办共产党的法律；三是成立联合政府，由二、三名党外人士担任国务院副总理；四是改变现在以党代政现象，充分发挥政府作用；五是改变现在不合理的选举制度，实行竞选制度；七是自由选择职业；八是成立农民会，领导农民运动。”(辽宁9．3)

   薛克昌(北京农业大学右派学生)：

   我是集右派言论之大成。

   民盟有许多高级知识分子，可以在文化、艺术、科学方面做领导工作。党应该把这部分权利(力)交给民盟，党只要在军事、政治、经济方面领导就行了。科学家大多不是共产党员，因此高等学校也应该不让党员参加领导。

   我赞成高等学校取消党委制，由民盟来搞。

   信仰什么是自己的自由，可以自由选择，这是宪法上规定的。因此，是否一定要改造思想和信仰马列主义，是个问题。

   “百花齐放、百家争鸣”不应以马克思列宁主义为指领思想。

   苏共二十次代表大会以后，我认为社会主义完了。马列主义这下子完全完了。从目前现象看，马克思列宁主义到了最后考验的时期，成功失败都由此决定。政治经济学已过时，特别是社会科学原理，当时马克思、恩格斯没有什么实践，原理是否对，是个问题；政治经济学的理论，只能作为一个遗产来接受，那时分析的是十九世纪中叶的情况，现在经济发展了，是否适合是个问题。唯物论的根本原则是对的，但停留存在


# Question 6

'''
Wisconsin State Fair is one of the largest midsummer celebrations in the Midwest Allis, showcasing the agriculture skills and prowess of the state. The Event organizers hired few part-time employees to work at the fair and the agreed salary paid to them are as given below:

Weekdays --- 80 / hour
Weekends --- 50 / hour

Justin is a part-time employee working at the fair. Number of hours Justin has worked in the weekdays is 10 more than the number of hours he had worked during weekends. If the total salary paid to him in this month is known, write a program to estimate the number of hours he had worked during weekdays and the number of hours he had worked during weekends.

Input Format:
First line of the input is a double value that corresponds to the total salary paid to Justin.

Output Format:
First line of the output should display the number of hours Justin has worked during the weekdays.
Second line of the output should display the number of hours Justin has worked during the weekends.
Refer sample input and output for formatting specifications.
[All text in bold corresponds to input and rest corresponds to output.]

Sample Input and Output:
Enter the total salary paid
2750
Number of weekday hours is 25
Number of weekend hours is 15
'''

# part time employee

# Weekdays --- 80 / hour , X
# Weekends --- 50 / hour , Y

# no of hour justin work in weekdays is 10 more
# than the number of hour he working in weekends

# weekdays = 10 + weekends  -->> X
# Ts = (known) = 80 (Y) + 50 (X) -->> Total Salary
# Ts = 80Y + 50(10+Y)

Ts = int(input("Enter the total salary paid"))

Y = int((Ts - 800) / 130)
X = int(10 + Y)

print(f"Number of weekday hours is {X}")
print(f"Number of weekend hours is {Y}")


4px 1px;box-shadow:0 0 0 2px #dee0e2}.tox:not([dir=rtl]) .tox-statusbar__path>*{margin-right:4px}.tox:not([dir=rtl]) .tox-statusbar__branding{margin-left:2ch}.tox[dir=rtl] .tox-statusbar{flex-direction:row-reverse}.tox[dir=rtl] .tox-statusbar__path>*{margin-left:4px}.tox .tox-throbber{z-index:1299}.tox .tox-throbber__busy-spinner{align-items:center;background-color:rgba(255,255,255,.6);bottom:0;display:flex;justify-content:center;left:0;position:absolute;right:0;top:0}.tox .tox-tbtn{align-items:center;background:0 0;border:0;border-radius:3px;box-shadow:none;color:#222f3e;display:flex;flex:0 0 auto;font-size:14px;font-style:normal;font-weight:400;height:34px;justify-content:center;margin:3px 0 2px 0;outline:0;overflow:hidden;padding:0;text-transform:none;width:34px}.tox .tox-tbtn svg{display:block;fill:#222f3e}.tox .tox-tbtn.tox-tbtn-more{padding-left:5px;padding-right:5px;width:inherit}.tox .tox-tbtn:focus{background:#dee0e2;border:0;box-shadow:none}.tox .tox-tbtn:hover{background:#dee0e2;border:0;box-shadow:none;color:#222f3e}.tox .tox-tbtn:hover svg{fill:#222f3e}.tox .tox-tbtn:active{background:#c8cbcf;border:0;box-shadow:none;color:#222f3e}.tox .tox-tbtn:active svg{fill:#222f3e}.tox .tox-tbtn--disabled .tox-tbtn--enabled svg{fill:rgba(34,47,62,.5)}.tox .tox-tbtn--disabled,.tox .tox-tbtn--disabled:hover,.tox .tox-tbtn:disabled,.tox .tox-tbtn:disabled:hover{background:0 0;border:0;box-shadow:none;color:rgba(34,47,62,.5);cursor:not-allowed}.tox .tox-tbtn--disabled svg,.tox .tox-tbtn--disabled:hover svg,.tox .tox-tbtn:disabled svg,.tox .tox-tbtn:disabled:hover svg{fill:rgba(34,47,62,.5)}.tox .tox-tbtn--enabled,.tox .tox-tbtn--enabled:hover{background:#c8cbcf;border:0;box-shadow:none;color:#222f3e}.tox .tox-tbtn--enabled:hover>*,.tox .tox-tbtn--enabled>*{transform:none}.tox .tox-tbtn--enabled svg,.tox .tox-tbtn--enabled:hover svg{fill:#222f3e}.tox .tox-tbtn--enabled.tox-tbtn--disabled svg,.tox .tox-tbtn--enabled:hover.tox-tbtn--disabled svg{fill:rgba(34,47,62,.5)}.tox .tox-tbtn:focus:not(.tox-tbtn--disabled){color:#222f3e}.tox .tox-tbtn:focus:not(.tox-tbtn--disabled) svg{fill:#222f3e}.tox .tox-tbtn:active>*{transform:none}.tox .tox-tbtn--md{height:51px;width:51px}.tox .tox-tbtn--lg{flex-direction:column;height:68px;width:68px}.tox .tox-tbtn--return{align-self:stretch;height:unset;width:16px}.tox .tox-tbtn--labeled{padding:0 4px;width:unset}.tox .tox-tbtn__vlabel{display:block;font-size:10px;font-weight:400;letter-spacing:-.025em;margin-bottom:4px;white-space:nowrap}.tox .tox-number-input{border-radius:3px;display:flex;margin:3px 0 2px 0;p


rces.RealBox
import top.sankokomi.wirebare.ui.resources.RealColumn
import top.sankokomi.wirebare.ui.resources.TabData
import top.sankokomi.wirebare.ui.resources.Typographies
import top.sankokomi.wirebare.ui.util.copyTextToClipBoard
import top.sankokomi.wirebare.ui.util.showToast
import top.sankokomi.wirebare.ui.util.statusBarHeightDp
import java.text.DecimalFormat
import java.text.DecimalFormatSymbols
import java.util.Locale
import kotlin.math.min

@Composable
fun WireInfoUI.WireInfoUIPage(
    req: HttpReq?,
    rsp: HttpRsp?
) {
    var request = req
    var response = rsp
    LaunchedEffect(Unit) {
        withContext(Dispatchers.IO) {
            when {
                req != null -> {
                    httpRoom.httpDao().queryRspId(req.id)?.let { rspId ->
                        response = httpRoom.httpDao().queryHttpRspById(rspId).firstOrNull()
                    }
                }

                rsp != null -> {
                    httpRoom.httpDao().queryReqId(rsp.id)?.let { reqId ->
                        request = httpRoom.httpDao().queryHttpReqById(reqId).firstOrNull()
                    }
                }
            }
        }
    }
    val strRequestInfo = stringResource(R.string.request_info_title)
    val strResponseInfo = stringResource(R.string.response_info_title)
    val strFormatter = stringResource(R.string.req_rsp_info_formatter)
    val tabDataList = remember {
        listOf(
            TabData(R.drawable.ic_request, strRequestInfo),
            TabData(R.drawable.ic_response, strResponseInfo),
            TabData(R.drawable.ic_format, strFormatter)
        )
    }
    val pagerState = rememberPagerState { tabDataList.size }
    val titleBarText = remember { mutableStateOf(tabDataList.first().text) }
    val anim = remember { Animatable(1f) }
    LaunchedEffect(Unit) {
        if (rsp != null) {
            titleBarText.value = tabDataList[1].text
            pagerState.animateScrollToPage(
                1,
                animationSpec = tween(0)
            )
        }
    }
    RealBox(modifier = Modifier.background(Colors.background)) {
        RealColumn(
            modifier = Modifier.zIndex(1f)
        ) {
            Spacer(
                modifier = Modifier
                    .fillMaxWidth()
                    .height(statusBarHeightDp)
                    .background(Colors.background)
            )
            AppTitleBar(text = titleBarText.value)
        }
        HorizontalPager(
            state = pagerState,
            userScrollEnabled = false,
            beyondViewportPageCount = 3,
            modifier = Modifier
                .fillMaxSize()
                .padding(top = ((1f - anim.value) * 4).dp)
                .alpha(1f - ((1f - anim.value)))
        ) {
            when (it) {
                0 -> WireInfoRequestUIPage(request)

                1 -> WireInfoResponseUIPage(response)

                2 -> WireInfoFormatterUIPage(
                    contentEncoding = response?.contentEncoding ?: "",
                    contentType = response?.contentType ?: "",
                    sessionId = response?.id ?: ""
                )
            }
        }
        val rememberScope = rememberCoroutineScope()
        RealBox(
            modifier = Modifier
                .align(Alignment.BottomCenter)
                .fillMaxWidth()
                .background(


ര്‍ക്ക് തങ്ങളുടെ രക്ഷിതാവിന്‍റെ അടുക്കല് താഴ്ഭാഗത്തു കൂടി അരുവികള് ഒഴുകിക്കൊണ്ടിരിക്കുന്ന സ്വര്‍ഗത്തോപ്പുകളുണ്ട്. അവര് അവിടെ നിത്യവാസികളായിരിക്കും. പരിശുദ്ധരായ ഇണകളും (അവര്‍ക്കുണ്ടായിരിക്കും.) കൂടാതെ അല്ലാഹുവിന്‍റെ പ്രീതിയും. അല്ലാഹു തന്‍റെ ദാസന്‍മാരുടെ കാര്യങ്ങള് കണ്ടറിയുന്നവനാകുന്നു."
  },
  {
    "surah_number": 3,
    "verse_number": 16,
    "content":
        "ഞങ്ങളുടെ നാഥാ, ഞങ്ങളിതാ വിശ്വസിച്ചിരിക്കുന്നു. അതിനാല് ഞങ്ങളുടെ പാപങ്ങള് പൊറുത്തുതരികയും, നരക ശിക്ഷയില് നിന്ന് ഞങ്ങളെ രക്ഷിക്കുകയും ചെയ്യേണമേ എന്ന് പ്രാര്‍ത്ഥിക്കുന്നവരും,"
  },
  {
    "surah_number": 3,
    "verse_number": 17,
    "content":
        "ക്ഷമ കൈക്കൊള്ളുന്നവരും, സത്യം പാലിക്കുന്നവരും, ഭക്തിയുള്ളവരും ചെലവഴിക്കുന്നവരും, രാത്രിയുടെ അന്ത്യയാ


DIFF_MIN.html">PTRDIFF_MIN
Largest negative value of a ptrdiff_t integer.
SIZE_MAX
Maximum value of a size_t integer.
UINT_FAST16_MAX
Maximum value of our uint_fast16_t type.
UINT_FAST32_MAX
Maximum value of our uint_fast32_t type.
UINT_FAST64_MAX
Maximum value of our uint_fast64_t type.
UINT_FAST8_MAX
Maximum value of our uint_fast8_t type.
UINT_LEAST16_MAX
Maximum value of our uint_least16_t type.
UINT_LEAST32_MAX
Maximum value of our uint_least32_t type.
UINT_LEAST64_MAX
Maximum value of our uint_least64_t type.
UINT_LEAST8_MAX
Maximum value of our uint_least8_t type.
UINT16_MAX
Maximum value of an unsigned 16-bit integer.
UINT32_MAX
Maximum value of an unsigned 32-bit integer.
UINT64_MAX
Maximum value of an unsigned 64-bit integer.
UINT8_MAX
Maximum value of an unsigned 8-bit integer.
UINTMAX_MAX</B


res, bodyRequest, "insert");
      res.send(result);
    });

    router.delete('/remove', async (req, res) =>{
      let bodyRequest = req.body;
      const result = await this.accessTransportation(res, bodyRequest, "delete");
      res.send(result);
    });

    router.get('/search', async (req, res) => {
        var urlParts = url.parse(req.url, true);
        var query = urlParts.query;
        var msg = 'search for ' + query.var1;
        console.log(msg);
        const list = await this.accessTransportation(res, {speed: query.var1}, "query");
        res.send(list);
    });

    //col1.find({"speed": {$gte: "150"}})
    router.get('/search2', async (req, res) => {
      var urlParts = url.parse(req.url, true);
      var query = urlParts.query;
      var msg = 'search for ' + query.var1;
      console.log(msg);
      const list = this.accessTransportation(res, {speed: {$gte: query.var1}}, "query");
      res.send(list);
  });

    router.get('/vehicle/:vname', (req, res) => {
        var vname = req.params.vname;
        console.log('Query for vehicle name: ' + vname);
        this.accessTransportation(res, {vehicle: vname}, "query").then((list) => {
            res.send(list);
        });
    });

    router.param('vname', (req, res, next, value) => {
        console.log('The param value is: ' + value);
        next();
    });

    this.expressApp.use('/', router);

    this.expressApp.use('/images', express.static(__dirname+'/img'));
    this.expressApp.use('/', express.static(__dirname+'/pages'));
  }

}

export {App};export default (n: number): number[] => {
  let primes: number[] = []
  let tempN = n
  while (tempN % 2 === 0) {
    if (tempN === 2) break;
    tempN /= 2
    primes.push(2)
  }
  for (let i = 3; i <= Math.sqrt(n); i += 2) {
    while (tempN !== i && tempN % i === 0) {
      tempN /= i
      primes.push(i)
    }
  }
  if (tempN !== 1) primes.push(tempN);
  return primes
}
import "reflect-metadata"
import {ChatState} from "../ChatState";
import {Menu, MenuClass} from "../menu/Menu";
import {Class} from "../util";

export const classProperties: WeakMap<any,{}> = new WeakMap();

type ArgumentOptions = {name: string, position: {col: number,row: number}, menuClass: MenuClass}
type ActionOptions = {name: string, position: {col: number,row: number}}

/**
 * Декораторы
 */

export function Argument(options: ArgumentOptions) {
    return function CMDArgumentDecorator(proto: Object, propertyKey: string): any {
        if (!classProperties.has(proto)) classProperties.set(proto, {});
        var argumentProperty = classProperties.get(proto)['argument'];
        if (!argumentProperty) argumentProperty = classProperties.get(proto)['argument'] = {};
        argumentProperty[propertyKey] = options;
    }
}

export function Action(options: ActionOptions) {
    return function CMDArgumentDecorator(proto: Object, propertyKey: string): any {
        if (!classProperties.has(proto)) classProperties.set(proto, {});
        var actionProperty = classProperties.get(proto)['action'];
        if (!actionProperty) actionProperty = classProperties.get(proto)['action'] = {};
        actionProperty[propertyKey] = options;
    }
}

export function Inject(proto: Object, propertyKey: string): any {
    if (!classProperties.has(proto)) classProperties.set(proto, {});
    var actionProperty = classProperties.get(proto)['inject'];
    if (!actionProperty) actionProperty = classPrope


nitialize test log object
            testLog = new TestUtil.TestLog(expectedOut);
        }

        [Fact]
        [OuterLoop]
        static public int TestEntryPoint()
        {
            //Start recording
            testLog.StartRecording();

            try
            {
                Console.WriteLine("In try");
            }
            finally
            {
                Console.WriteLine("In finally");
            }
            try
            {
                Console.WriteLine("In try");
            }
            finally
            {
                Console.WriteLine("In finally");
            }

            // stop recoding
            testLog.StopRecording();

            return testLog.VerifyOutput();
        }
    }
}


romCopy != null) {
      buffer.writeObject(localFwdFromCopy);
    }
    final localViaBotIdCopy = viaBotId;
    if (localViaBotIdCopy != null) {
      buffer.writeInt64(localViaBotIdCopy);
    }
    final localViaBusinessBotIdCopy = viaBusinessBotId;
    if (localViaBusinessBotIdCopy != null) {
      buffer.writeInt64(localViaBusinessBotIdCopy);
    }
    final localReplyToCopy = replyTo;
    if (localReplyToCopy != null) {
      buffer.writeObject(localReplyToCopy);
    }
    buffer.writeDateTime(date);
    buffer.writeString(message);
    final localMediaCopy = media;
    if (localMediaCopy != null) {
      buffer.writeObject(localMediaCopy);
    }
    final localReplyMarkupCopy = replyMarkup;
    if (localReplyMarkupCopy != null) {
      buffer.writeObject(localReplyMarkupCopy);
    }
    final localEntitiesCopy = entities;
    if (localEntitiesCopy != null) {
      buffer.writeVectorObject(localEntitiesCopy);
    }
    final localViewsCopy = views;
    if (localViewsCopy != null) {
      buffer.writeInt32(localViewsCopy);
    }
    final localForwardsCopy = forwards;
    if (localForwardsCopy != null) {
      buffer.writeInt32(localForwardsCopy);
    }
    final localRepliesCopy = replies;
    if (localRepliesCopy != null) {
      buffer.writeObject(localRepliesCopy);
    }
    final localEditDateCopy = editDate;
    if (localEditDateCopy != null) {
      buffer.writeDateTime(localEditDateCopy);
    }
    final localPostAuthorCopy = postAuthor;
    if (localPostAuthorCopy != null) {
      buffer.writeString(localPostAuthorCopy);
    }
    final localGroupedIdCopy = groupedId;
    if (localGroupedIdCopy != null) {
      buffer.writeInt64(localGroupedIdCopy);
    }
    final localReactionsCopy = reactions;
    if (localReactionsCopy != null) {
      buffer.writeObject(localReactionsCopy);
    }
    final localRestrictionReasonCopy = restrictionReason;
    if (localRestrictionReasonCopy != null) {
      buffer.writeVectorObject(localRestrictionReasonCopy);
    }
    final localTtlPeriodCopy = ttlPeriod;
    if (localTtlPeriodCopy != null) {
      buffer.writeInt32(localTtlPeriodCopy);
    }
    final localQuickReplyShortcutIdCopy = quickReplyShortcutId;
    if (localQuickReplyShortcutIdCopy != null) {
      buffer.writeInt32(localQuickReplyShortcutIdCopy);
    }
    final localEffectCopy = effect;
    if (localEffectCopy != null) {
      buffer.writeInt64(localEffectCopy);
    }
    final localFactcheckCopy = factcheck;
    if (localFactcheckCopy != null) {
      buffer.writeObject(localFactcheckCopy);
    }
    final localReportDeliveryUntilDateCopy = reportDeliveryUntilDate;
    if (localReportDeliveryUntilDateCopy != null) {
      buffer.writeDateTime(localReportDeliveryUntilDateCopy);
    }
    final localPaidMessageStarsCopy = paidMessageStars;
    if (localPaidMessageStarsCopy != null) {
      buffer.writeInt64(localPaidMessageStarsCopy);
    }
    final localSuggestedPostCopy = suggestedPost;
    if (localSuggestedPostCopy != null) {
      buffer.writeObject(localSuggestedPostCopy);
    }

    // Finished serialization.
  }

  @override
  Map<String, dynamic> toJson() {
    final returnValue = <String, dynamic>{
      "\$hash": "9815cec8",
      "\$name


败

雾雨魔理沙

さっぱり要領を得ないな。

みんな花の事には気が付いている筈なのに。

完全不得要领啊。
大家明明应该都注意到花的事情了。

如果玩家被击败

铃仙·优昙华院·因幡

花のことは私が調べます。
でも危険は感じられないけどね。

花的事情由我来调查。
不过倒是感觉不到危险呢。

## 雾雨魔理沙 vs. 魂魄妖梦 (Episode 3 or 4 or 5)

BGM: 東方妖々夢　～ Ancient Temple

BGM: 东方妖妖梦　～ Ancient Temple

<tr class="tt-header-white" id="雾雨魔理沙_vs._魂魄妖梦_(Episode_3_or_4_or_5)-2" data-pos="["\u96fe\u96e8\u9b54\u7406\u6c99 vs. \u9b42\u9b44\u5


 U+70a4, U+70ab-70ad, U+70af, U+70b3, U+70b7-70b9,
    U+70c8, U+70cb, U+70cf, U+70d8-70d9, U+70dd, U+70df, U+70f1, U+70f9, U+70fd,
    U+7104, U+7109, U+710c, U+7119-711a, U+711e, U+7126, U+7130, U+7136, U+7147,
    U+7149-714a, U+714c, U+714e, U+7150, U+7156, U+7159, U+715c, U+715e,
    U+7164-7167, U+7169, U+716c, U+716e, U+717d, U+7184, U+7189-718a, U+718f,
    U+7192, U+7194, U+7199, U+719f, U+71a2, U+71ac, U+71b1, U+71b9-71ba, U+71be,
    U+71c1, U+71c3, U+71c8-71c9, U+71ce, U+71d0, U+71d2, U+71d4-71d5, U+71df,
    U+71e5-71e7, U+71ed-71ee, U+71fb-71fc, U+71fe-7200, U+7206, U+7210, U+721b,
    U+722a, U+722c-722d;
}
/* [80] */
@font-face {
  font-family: "Noto Serif KR";
  font-style: normal;
  font-weight: 400;
  src: url(https://fonts.gstatic.com/s/notoserifkr/v28/3JnoSDn90Gmq2mr3blnHaTZXbOtLJDvui3JOncjmeM5z4ZvTefxutxWKI13DA9agQzxl4iCfvB7KDWw.80.woff2)
    format("woff2");
  unicode-range:
    U+6d5a, U+6d5c, U+6d63, U+6d66, U+6d69-6d6a, U+6d6c, U+6d6e, U+6d74,
    U+6d78-6d79, U+6d7f, U+6d85, U+6d87-6d89, U+6d8c-6d8e, U+6d91, U+6d93,
    U+6d95, U+6daf, U+6db2, U+6db5, U+6dc0, U+6dc3-6dc7, U+6dcb, U+6dcf, U+6dd1,
    U+6dd8-6dda, U+6dde, U+6de1, U+6de8, U+6dea-6deb, U+6dee, U+6df1, U+6df3,
    U+6df5, U+6df7-6dfb, U+6e17, U+6e19-6e1b, U+6e1f-6e21, U+6e23-6e26,
    U+6e2b-6e2d, U+6e32, U+6e34, U+6e36, U+6e38, U+6e3a, U+6e3c-6e3e,
    U+6e43-6e44, U+6e4a, U+6e4d, U+6e56, U+6e58, U+6e5b-6e5c, U+6e5e-6e5f,


d2,d4		* B
	moveq.l	#63,d5
	lsr.w	#5,d2
	and.w	d2,d5		* V
	lsr.w	#6,d2
	moveq.l	#31,d6
	and.w	d2,d6		* R

	mulu.w	d1,d4		* Composante * coef
	mulu.w	d1,d5		*
	mulu.w	d1,d6		*

	lsr.l	#6,d4		* decale
	lsr.l	#6,d5		*
	lsr.l	#6,d6		*

	lsl.w	#6,d6		* Recompose la couleur en 16 bits
	or.w	d5,d6		* Falcon
	lsl.w	#5,d6		*
	or.w	d4,d6		*
	move.w	d6,(a0)+	* et la place dans la table

	addq.w	#1,d1		* 64 niveaux de coef
	cmp.w	#64,d1
	bne.s	deg
	addq.l	#2,a4		* Couleur suivante
	dbra.w	d0,coul		* Gestion boucle

	*-----------------------------------------------
	* Precharge registres
	*-----------------------------------------------

	lea	random_tab(pc),a6	* Pointe sur table random
	lea	figure(pc),a0		* table vals initiales
	move.l	a0,usp

	*-----------------------------------------------
	* Main loop
	*-----------------------------------------------

	bsr	genere			* Intro: map 2d
	bsr	affiche			* en non light source
	bsr	helpaff			* + boite d'aide

main:	move.b	$fffffc02.w,tch		*--------- Main loop ---------*

	cmp.b	#$1f,tch		* Help case
	bne.s	.next
	bsr	SaveImage
	bra	loop_tst
.next:
	cmp.b	#$62,tch		* Help case
	bne.s	tch_tst
	bsr	helpaff
	bra	loop_tst
tch_tst:
	cmp.b	#59,tch			* Else
	blt	loop_tst		*
	cmp.b	#64,tch			*
	bgt	loop_tst		*

	cmp.b	#59,tch			* F1
	bne.s	map_something		*
	bsr	genere			* Genere
	move.w	choix(pc),d0		*
	move.w	#-1,choix		*
	bra.s	no_get_ch		*
map_something:
	moveq.l	#0,d0			* F2  F6
	move.b	tch(pc),d0		*
	sub.b	#60,d0			*
no_get_ch:
	cmp.w	choix(pc),d0		*
	beq.s	loop_tst		*
	tst.w	d0			* F2: 2D view
	sne.b	test			* pas d'effacement
	cmp.w	#3,d0			* F5: 2D view + lightsource
	bne.s	.aff2			*
	clr.b	test			* pas d'effacement
.aff2:	cmp.w	#4,d0			* F6: 3D view + lightsource
	bne.s	.aff3			*
	cmp.w	#2,choix		* Si choix
	sne.b	test			*
.aff3:	cmp.w	#2,d0			* F2: 3D view
	bne.s	.aff4


.686, 0.122, 0.824, 0.844, 0.173, -0.63, -0.907, -0.439, 0.38, 0.875, 0.647, -0.107, -0.764, -0.788,
                -0.163, 0.592, 0.856, 0.413, -0.371, -0.852, -0.629, 0.118, 0.774, 0.794, 0.155, -0.62, -0.89, -0.424,
                0.397, 0.896, 0.658, -0.124, -0.808, -0.829};

        double[] result = t1_1.bandPassFilter(this.signal1, 4, 12, 18);
        Assertions.assertArrayEquals(result, out, 0.001);
    }

    @Test
    public void Type1BandPassTest2() {
        final double[] out = {0.0, 0.023, 0.044, -0.076, -0.233, 0.016, 0.529, 0.349, -0.599, -0.87, 0.17, 1.058, 0.504,
                -0.674, -0.904, 0.02, 0.857, 0.516, -0.537, -0.824, 0.079, 0.881, 0.447, -0.601, -0.834, 0.048, 0.861,
                0.509, -0.539, -0.83, 0.047, 0.852, 0.452, -0.583, -0.815, 0.074, 0.875, 0.487, -0.571, -0.846, 0.045,
                0.862, 0.476, -0.563, -0.815, 0.064, 0.861, 0.472, -0.576, -0.837, 0.057, 0.871, 0.483, -0.566, -0.826,
                0.054, 0.857, 0.472, -0.57, -0.827, 0.062, 0.87, 0.477, -0.572, -0.831, 0.055, 0.862, 0.478, -0.567,
                -0.827, 0.059, 0.865, 0.475, -0.573, -0.83, 0.058, 0.866, 0.478, -0.568, -0.829, 0.056, 0.864, 0.476,
                -0.57, -0.828, 0.059, 0.865, 0.477, -0.57, -0.83, 0.057, 0.864, 0.477, -0.57, -0.828, 0.058, 0.864,
                0.476, -0.57, -0.829};

        double[] result = t1_2.bandPassFilter(this.signal2,4, 12, 30);
        Assertions.assertArrayEquals(result, out, 0.001);
    }

    @Test
    public void Type1BandStopTest1() {
        final double[] out = {0.0, 0.201, -0.373, 0.732, -0.132, -0.042, 1.057, 0.239, 0.069, 1.347, 0.861, 0.011,
                1.165, 1.267, -0.216, 0.275, 1.055, -0.508, -0.982, 0.283, -0.583, -1.821, -0.504, -0.159, -1.594,
                -0.755, 0.685, -0.377, -0.447, 1.391, 1.01, -0.064, 1.302, 1.642, -0.062, 0.279, 1.212, -0.384, -1.078,
                0.206, -0.538, -1.849, -0.589, -0.123, -1.499, -0.732, 0.719, -0.275, -0.391, 1.372, 1.0


lv_expr_2_0= ruleExpression ) ) ( (lv_block_3_0= ruleBlock ) ) ( ( ( 'else' )=>otherlv_4= 'else' ) ( ( (lv_else_5_1= ruleS_If | lv_else_5_2= ruleBlock ) ) ) )? )
            // InternalGaml.g:1536:3: ( (lv_key_0_0= 'if' ) ) ( (lv_firstFacet_1_0= 'condition:' ) )? ( (lv_expr_2_0= ruleExpression ) ) ( (lv_block_3_0= ruleBlock ) ) ( ( ( 'else' )=>otherlv_4= 'else' ) ( ( (lv_else_5_1= ruleS_If | lv_else_5_2= ruleBlock ) ) ) )?
            {
            // InternalGaml.g:1536:3: ( (lv_key_0_0= 'if' ) )
            // InternalGaml.g:1537:4: (lv_key_0_0= 'if' )
            {
            // InternalGaml.g:1537:4: (lv_key_0_0= 'if' )
            // InternalGaml.g:1538:5: lv_key_0_0= 'if'
            {
            lv_key_0_0=(Token)match(input,28,FOLLOW_23); if (state.failed) return current;
            if ( state.backtracking==0 ) {

              					newLeafNode(lv_key_0_0, grammarAccess.getS_IfAccess().getKeyIfKeyword_0_0());

            }
            if ( state.backtracking==0 ) {

              					if (current==null) {
              						current = createModelElement(grammarAccess.getS_IfRule());
              					}
              					setWithLastConsumed(current, "key", lv_key_0_0, "if");

            }

            }

            }

            // InternalGaml.g:1550:3: ( (lv_firstFacet_1_0= 'condition:' ) )?
            int alt34=2;
            int LA34_0 = input.LA(1);

            if ( (LA34_0==29) ) {
                alt34=1;
            }
            switch (alt34) {
                case 1 :
                    // InternalGaml.g:1551:4: (lv_firstFacet_1_0= 'condition:' )
                    {
                    // InternalGaml.g:1551:4: (lv_firstFacet_1_0= 'condition:' )
                    // InternalGaml.g:1552:5: lv_firstFacet_1_0= 'condition:'
                    {
                    lv_firstFacet_1_0=(Token)match(input,29,FOLLOW_5); if (state.failed) return current;
                    if ( state.backtracking==0 ) {

                      					newLeafNode(lv_firstFacet_1_0, grammarAccess.getS_IfAccess().getFirstFacetConditionKeyword_1_0());

                    }
                    if ( state.backtracking==0 ) {

                      					if (current==null) {
                      						current = createModelElement(grammarAccess.getS_IfRule());
                      					}
                      					setWithLastConsumed(current, "firstFacet", lv_firstFacet_1_0, "condition:");

                    }

                    }

                    }
                    break;

            }

            // InternalGaml.g:1564:3: ( (lv_expr_2_0= ruleExpression ) )
            // InternalGaml.g:1565:4: (lv_expr_2_0= ruleExpression )
            {
            // InternalGaml.g:1565:4: (lv_expr_2_0= ruleExpression )
            // InternalGaml.g:1566:5: lv_expr_2_0= ruleExpression
            {
            if ( state.backtracking==0 ) {

              					newCompositeNode(grammarAccess.getS_IfAccess().getExprExpressionParserRuleCall_2_0());

            }


C774 \uBD80\uC801\uD569\uD569\uB2C8\uB2E4."},
        {"actions.can.only.be.read.", "\uC791\uC5C5\uC740 '\uC77D\uAE30' \uC804\uC6A9\uC785\uB2C8\uB2E4."},
        {"permission.name.name.syntax.invalid.",
                "\uAD8C\uD55C \uC774\uB984 [{0}] \uAD6C\uBB38\uC774 \uBD80\uC801\uD569\uD568: "},
        {"Credential.Class.not.followed.by.a.Principal.Class.and.Name",
                "\uC778\uC99D\uC11C \uD074\uB798\uC2A4 \uB2E4\uC74C\uC5D0 \uC8FC\uCCB4 \uD074\uB798\uC2A4\uC640 \uC774\uB984\uC774 \uC5C6\uC2B5\uB2C8\uB2E4."},
        {"Principal.Class.not.followed.by.a.Principal.Name",
                "\uC8FC\uCCB4 \uD074\uB798\uC2A4 \uB2E4\uC74C\uC5D0 \uC8FC\uCCB4 \uC774\uB984\uC774 \uC5C6\uC2B5\uB2C8\uB2E4."},
        {"Principal.Name.must.be.surrounded.by.quotes",
                "\uC8FC\uCCB4 \uC774\uB984\uC740 \uB530\uC634\uD45C\uB85C \uBB36\uC5B4\uC57C \uD569\uB2C8\uB2E4."},
        {"Principal.Name.missing.end.quote",
                "\uC8FC\uCCB4 \uC774\uB984\uC5D0 \uB2EB\uB294 \uB530\uC634\uD45C\uAC00 \uB204\uB77D\uB418\uC5C8\uC2B5\uB2C8\uB2E4."},
        {"PrivateCredentialPermission.Principal.Class.can.not.be.a.wildcard.value.if.Principal.Name.is.not.a.wildcard.value",
                "\uC8FC\uCCB4 \uC774\uB984\uC774 \uC640\uC77C\uB4DC \uCE74\uB4DC \uBB38\uC790(*) \uAC12\uC774 \uC544\uB2CC \uACBD\uC6B0 PrivateCredentialPermission \uC8FC\uCCB4 \uD074\uB798\uC2A4\uB294 \uC640\uC77C\uB4DC \uCE74\uB4DC \uBB38\uC790(*) \uAC12\uC77C \uC218 \uC5C6\uC2B5\uB2C8\uB2E4."},
        {"CredOwner.Principal.Class.class.Principal.Name.name",
                "CredOwner:\n\t\uC8FC\uCCB4 \uD074\uB798\uC2A4 = {0}\n\t\uC8FC\uCCB4 \uC774\uB984 = {1}"},

        // javax.security.auth.x500
        {"provided.null.name", "\uB110 \uC774\uB984\uC744 \uC81C\uACF5\uD588\uC2B5\uB2C8\uB2E4."},


12px 15px;
}

.content_table tbody tr{
    border-bottom: 1px solid #dddddd;
    font-weight:500;
}

.content_table tbody tr:nth-of-type(even){
    background-color: #f3f3f3;
}

.content_table tbody tr:last-of-type{
    border-bottom: 2px solid #001F3F;
}

.chart_style{
    max-width: 580px;
    border-radius: 15px;
    overflow: hidden;
    box-shadow: 0 0 20px rgba(0,0,0,0.15);
}

.tooltip {
    position: absolute;
    opacity: 0;
    background-color: #f9f9f9;
    border: 1px solid #d3d3d3;
    padding: 2px;
    color: #007979c3;
}

/* 位置有變 */
.chart_container {
    margin: 10px 0;  /* 保留左右20px的外边距，上下为0 */
}
#barChart text {
    font-weight: 600; /* Make the font bold */
    font-size: 11px; /* Adjust the font size as needed */
    fill: #333; /* Change the text color if needed */
}

.bar-chart, .pie-chart {
    margin-bottom: 10px;
}

.bar-chart{
    flex: 1;
    display: flex;
    justify-content: center;
    align-items: center;
    flex-direction: column;
    padding-bottom: 3px;
}

.place {
    display: flex;
    justify-content: center;
    align-items: center;
}

.chart_title{
    font-weight: 800;
    font-size: 17px;
    padding-top: 2%;
}

.pie-chart {
    flex: 1;
    display: flex;
    flex-direction: column; /* 使子元素垂直排列 */
    justify-content: center;
    align-items: center;
    padding-bottom: 3px;
}

.tooltip {
    position: absolute;
    opacity: 0;
    background-color: #fff;
    border: 1px solid #ddd;
    padding: 5px;
    border-radius: 5px;
    text-align: center;
    font-size: 12px;
    box-shadow: 0px 2px 5px rgba(0,0,0,0.2);
    pointer-events: none;
}

.tooltip.show {
    opacity: 1;
}@charset "UTF-8";

/* Inter Font */
:root {
  font-family: Inter, sans-serif;
  font-feature-settings: 'liga' 1, 'calt' 1; /* fix for Chrome */
}

@supports (font-variation-settings: normal) {
  :root { font-family: InterVariable, sans-serif; }
}

html, body, #app {
  width: 100%;
  height: 100%;
  margin: 0;
  padding: 0;
}

body {
  /* 根路径加载静态资源, 让每个路由下都能加载到 */
  cursor: url("/cursor/normal.cur"), auto;

  width: 100%;
  height: 100%;
  overflow-y: scroll;
  background: linear-gradient(90deg, rgba(247, 149, 51, 0.1) 0, rgba(243, 112, 85, 0.1) 15%, rgba(239, 78, 123, 0.1) 30%, rgba(161, 102, 171, 0.1) 44%, rgba(80, 115, 184, 0.1) 58%, rgba(16, 152, 173, 0.1) 72%, rgba(7, 179, 155, 0.1) 86%, rgba(109, 186, 130, 0.1) 100%);

  /* font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", "Helvetica Neue", Lato, Roboto, "


k", "Pilot Clock Winding/Setting Lever")

MirageF1:defineFloat("P_CLOCK_NEEDLE_M_G", 63, { 0, 1 }, "COMMON Clock Gauges", "Pilot Clock Minutes Needle")
MirageF1:defineFloat("P_CLOCK_NEEDLE_S_G", 62, { 0, 1 }, "COMMON Clock Gauges", "Pilot Clock Seconds Needle")
MirageF1:defineFloat("P_CLOCK_NEEDLE_H_G", 64, { 0, 1 }, "COMMON Clock Gauges", "Pilot Clock Hour Needle")
MirageF1:defineFloat("P_CLOCK_NEEDLE_C_G", 65, { 0, 1 }, "COMMON Clock Gauges", "Pilot Clock Counter Needle")

--Air Data Instrument Controls
MirageF1:definePotentiometer("P_ADI_SPEED_KNB", 1, 3200, 1270, { 0, 1 }, "COMMON Air Data Instrument Controls", "Pilot Mach/Airspeed Indicator Reference Airspeed Knob")
MirageF1:defineRotary("P_ADI_ALT_BARO_SLAVE", 1, 3202, 1053, "COMMON Air Data Instrument Controls", "Pilot Slaved Altimeter Barometric Pressure Setting Knob")
MirageF1:defineRotary("P_ADI_ALT_BARO_STBY", 1, 3204, 1072, "COMMON Air Data Instrument Controls", "Pilot Standby Altimeter Barometric Pressure Setting Knob")
MirageF1:defineToggleSwitch("P_ADI_PROBE_HEAT", 1, 3206, 477, "COMMON Air Data Instrument Controls", "Pilot Probe Heater Switch")

MirageF1:defineFloat("P_ADI_ALT_SL_NEEDLE_G", 1043, { 0, 1 }, "COMMON Air Data Instrument Controls Gauges", "Pilot Slaved Altimeter Needle")
MirageF1:defineFloat("P_ADI_ALT_SL_FLAG_G", 1044, { 0, 1 }, "COMMON Air Data Instrument Controls Gauges", "Pilot Slaved Altimeter Flag")
MirageF1:defineFloat("P_ADI_ALT_SL_T_DRUM_100_G", 1045, { 0, 1 }, "COMMON Air Data Instrument Controls Gauges", "Pilot Slaved Altimeter Top Drum 100")
MirageF1:defineFloat("P_ADI_ALT_SL_T_DRUM_10_G", 1046, { 0, 1 }, "COMMON Air Data Instrument Controls Gauges", "Pilot Slaved Altimeter Top Drum 10")
MirageF1:defineFloat("P_ADI_ALT_SL_T_DRUM_1_G", 1047, { 0, 1 }, "COMMON Air Data Instrument Controls Gauges", "Pilot Slaved Altimeter Top Drum 1")
MirageF1:defineFloat("P_ADI_ALT_SL_T_DRUM_01_G", 1048, { 0, 1 }, "COMMON Air Data Instrument Controls Gauges", "Pilot Slaved Altimeter Top Drum 0.1")
MirageF1:defineFloat("P_ADI_ALT_SL_L_DRUM_1000_G", 1049, { 0, 1 }, "COMMON Air Data Instrument Controls Gauges", "Pilot Slaved Altimeter Lower Drum 1000")
MirageF1:defineFloat("P_ADI_ALT_SL_L_DRUM_100_G", 1050, { 0, 1 }, "COMMON Air Data Instrument Controls Gauges", "Pilot Slaved Altimeter Lower Drum 100")
MirageF1:defineFloat("P_ADI_ALT_SL_L_DRUM_10_G", 1051, { 0, 1 }, "COMMON Air Data Instrument Controls Gauges", "Pilot Slaved Altimeter Lower Drum 10")
MirageF1:defineFloat("P_ADI_ALT_SL_L_DRUM_1_G", 1052, { 0, 1 }, "COMMON Air Data Instrument Controls Gauges", "Pilot Slaved Altimeter Lower Drum 1")
MirageF1:defineFloat("P_ADI_ALT_ST


emberRoles { get; set; } = new();

    public List<SubjectPermissionRelationDto> MemberPermissions { get; set; } = new();

    public static implicit operator AddTeamDto(TeamDetailDto team)
    {
        return new AddTeamDto()
        {
            Name = team.TeamBasicInfo.Name,
            Description = team.TeamBasicInfo.Description,
            Type = (TeamTypes)team.TeamBasicInfo.Type,
            Avatar = team.TeamBasicInfo.Avatar,
            AdminStaffs = team.TeamAdmin.Staffs,
            AdminRoles = team.TeamAdmin.Roles,
            AdminPermissions = team.TeamAdmin.Permissions,
            MemberRoles = team.TeamMember.Roles,
            MemberStaffs = team.TeamMember.Staffs,
            MemberPermissions = team.TeamMember.Permissions
        };
    }
}


 VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION: u32 = 1;
pub const VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME: &'static [u8; 25usize] =
    b"VK_GOOGLE_display_timing\0";
pub const VK_NV_sample_mask_override_coverage: u32 = 1;
pub const VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION: u32 = 1;
pub const VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME: &'static [u8; 36usize] =
    b"VK_NV_sample_mask_override_coverage\0";
pub const VK_NV_geometry_shader_passthrough: u32 = 1;
pub const VK_NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION: u32 = 1;
pub const VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME: &'static [u8; 34usize] =
    b"VK_NV_geometry_shader_passthrough\0";
pub const VK_NV_viewport_array2: u32 = 1;
pub const VK_NV_VIEWPORT_ARRAY2_SPEC_VERSION: u32 = 1;
pub const VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME: &'static [u8; 22usize] = b"VK_NV_viewport_array2\0";
pub const VK_NVX_multiview_per_view_attributes: u32 = 1;
pub const VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION: u32 = 1;
pub const VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME: &'static [u8; 37usize] =
    b"VK_NVX_multiview_per_view_attributes\0";
pub const VK_NV_viewport_swizzle: u32 = 1;
pub const VK_NV_VIEWPORT_SWIZZLE_SPEC_VERSION: u32 = 1;
pub const VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME: &'static [u8; 23usize] =
    b"VK_NV_viewport_swizzle\0";
pub const VK_EXT_discard_rectangles: u32 = 1;
pub const VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION: u32 = 1;
pub const VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME: &'static [u8; 26usize] =
    b"VK_EXT_discard_rectangles\0";
pub const VK_EXT_conservative_rasterization: u32 = 1;
pub const VK_EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION: u32 = 1;
pub const VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME: &'static [u8; 34usize] =
    b"VK_EXT_conservative_rasterization\0";
pub const VK_EXT_depth_clip_enable: u32 = 1;
pub const VK_EXT_DEPTH_CLIP_ENABLE_SPEC_VERSION: u32 = 1;
pub const VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME: &'static [u8; 25usize] =
    b"VK_EXT_depth_clip_enable\0";
pub const VK_EXT_swapchain_colorspace: u32 = 1;
pub const VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION: u32 = 4;
pub const VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME: &'static [u8; 28usize] =
    b"VK_EXT_swapchain_colorspace\0";
pub const V


 OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36"""
            )
        )
    }

    @Test
    fun `length is set on body if it is sent`() {
        val response = client(
            Request(POST, "$baseUrl/length")
                .body("12345").header("Content-Length", "5")
        )
        assertThat(response, hasStatus(OK).and(hasBody("5")))
    }

    @Test
    fun `length is ignored on body if it not well formed`() {
        val response = client(Request(POST, "$baseUrl/length").header("Content-Length", "nonsense").body("12345"))
        assertThat(response, hasStatus(OK).and(hasBody("5")))
    }

    @Test
    fun `gets the uri from the request`() {
        val response = client(Request(GET, "$baseUrl/uri?bob=bill"))

        assertThat(response.status, equalTo(OK))
        assertThat(response.bodyString(), equalTo("/uri?bob=bill"))
    }

    @Test
    fun `endpoint that blows up results in 500`() {
        val response = client(Request(GET, "$baseUrl/boom"))

        assertThat(response.status, equalTo(INTERNAL_SERVER_ERROR))
    }

    @Test
    fun `can handle multiple request headers`() {
        val response = client(
            Request(GET, "$baseUrl/request-headers").header("foo", "one").header("foo", "two").header("foo", "three")
        )

        assertThat(response.status, equalTo(OK))
        assertThat(
            response.bodyString(), equalTo(
                """foo: one
              |foo: two
              |foo: three""".trimMargin()
            )
        )
    }

    @Test
    open fun `treats multiple request headers as single item comma-separated list`() {
        val response = client(
            Request(GET, "$baseUrl/request-headers").header("foo", "one,two,three")
        )

        assertThat(response.status, equalTo(OK))
        assertThat(response.bodyString(), equalTo("foo: one,two,three"))
    }

    @Test
    fun `deals with streaming response`() {
        val response = client(Request(GET, "$baseUrl/stream"))

        assertThat(response.status, equalTo(OK))
        assertThat(response.bodyString(), equalTo("hello"))
    }

    @Test
    open fun `ok when length already set`() {
        val response = client(Request(GET, "$baseUrl/presetlength"))
        assertThat(response.status, equalTo(OK))
        assertThat(response.header("content-length"), equalTo("0"))
    }

    @Test
    open fun `can start on port zero and then get the port`() {
        routes(*routes.toTypedArray()).asServer(serverConfig(0, Immediate)).start().use {
            assertThat(client(Request(GET, "http://localhost:${it.port()}/uri")).status, equalTo(OK))
        }
    }

    @Test
    fun `returns 501 on illegal request`() {
        val actual = ClientForServerTesting.makeRequestWithInvalidMethod(baseUrl)
        assertThat(actual, equalTo(NOT_IMPLEMENTED))
    }

    @Test
    fun `can resolve request source`() {
        assertThat(
            client(Request(GET, "$baseUrl/request-source")),
            allOf(
                hasStatus(OK),
                hasHeader("x-address", clientAddress()),
                hasHeader("x-port", present()),
                hasHeader("x-scheme", requestScheme())
            )
        )
    }

    @Test
    open fun `illegal url doesn't expose stacktrace`() {
        assertThat(
            client(Request(GET, "$baseUrl/v1/foo//bar")).bodyString().lowercase(),


: Option<Vec<u8>>,
    /// A counter to keep track of forcing drawing.
    draw_ticks: usize,
}

impl panel::Panel for RamPanel {
    fn new(origin: Point32, height: u32, width: u32) -> Self {
        RamPanel {
            data: panel::PanelData::new(origin, height, width),
            cached_pc: None,
            cached_ram: None,
            draw_ticks: 0,
        }
    }

    fn draw(&mut self, window: &mut pwindow::PistonWindow, event: &pwindow::Event, args: DrawingContext) {
        let pc = args.pc.expect("RAM Panel's draw() method requires a PC as part of its context, but none was found.");
        let ram = args.ram.expect("RAM Panel's draw() method requires a RAM as part of its context, but none was found.");

        if !self.args_already_cached(pc, &ram) || self.draw_ticks % DRAW_INTERVAL == 0 {
            // Do the drawing, since we haven't done this one yet; then update the cache.
            self.draw_no_cache_check(window, event, pc, &ram);
            self.update_cache(pc, &ram);
        }

        self.draw_ticks = self.draw_ticks.wrapping_add(1);
    }

    fn get_state(&self) -> PanelData {
        self.data.clone()
    }
}

impl RamPanel {
    /// Checks if the given args are already in the cache and returns the result.
    fn args_already_cached(&self, pc: u16, ram: &Vec<u8>) -> bool {
        let cached_pc;
        if let Some(p) = self.cached_pc {
            cached_pc = p;
        } else {
            // If cached_pc is None, we don't match
            return false;
        }

        let cached_ram;
        if let Some(r) = &self.cached_ram {
            cached_ram = r;
        } else {
            // If cached_ram is None, we don't match
            return false;
        }

        let mut rams_are_equal = true;
        for (a, b) in cached_ram.iter().zip(ram) {
            if a != b {
                rams_are_equal = false;
                break;
            }
        }

        cached_pc == pc && rams_are_equal
    }

    /// Updates the cache with the given args.
    fn update_cache(&mut self, pc: u16, ram: &Vec<u8>) {
        self.cached_pc = Some(pc);
        self.cached_ram = Some(ram.clone());
    }

    /// Don't check the cache, just draw the Panel.
    fn draw_no_cache_check(&mut self, window: &mut pwindow::PistonWindow, event: &pwindow::Event, pc: u16, ram: &Vec<u8>) {
        // Construct the glyph cache
        let font_data: &[u8] = include_bytes!("../../assets/fonts/roboto/Roboto-Regular.ttf");
        let font: rusttype::Font<'static> = rusttype::Font::from_bytes(font_data).expect("Fatal error: Corrupt font binary?");
        let mut glyphcache = pwindow::glyph_cache::rusttype::GlyphCache::from_font(font, window.factory.clone(), pwindow::TextureSettings::new());

        let nrows = 12;
        let rects = self.draw_rows(window, event, nrows);

        if (pc as usize) < (nrows / 2) {
            return;  // Program counter is in a crazy place
        }
        for (idx, rect) in rects.iter().rev().enumerate() {
            let topleft = rect.topleft;
            let ramaddr = (pc as usize - (nrows / 2)) + idx;
            window.draw_2d(event, |context, graphics| {
                let text = format!("0x{:02x}",


/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include "cmockery.h"

#include "c.h"
#include "postgres.h"
#include "../define.c"

/* ==================== FreeStrFromDefGetString ==================== */

/*
 * Tests that need_free flag correctly set in defGetString method.
 */
void
test__DefGetString_NeedFreeFlag(void **state)
{
	bool need_free = false;
	char *value = NULL;

	/* case: T_String expected value: false */
	need_free = true;
	DefElem *e1 = makeDefElem("def_string", (Node *) makeString("none"));
	value = defGetString(e1, &need_free);
	assert_false(need_free);

	/* case: T_Integer expected value: true */
	need_free = false;
	DefElem *e2 = makeDefElem("def_int", (Node *) makeInteger(0));
	value = defGetString(e2, &need_free);
	assert_true(need_free);

	/* case: T_Float expected value: false */
	need_free = true;
	DefElem *e3 = makeDefElem("def_float", (Node *) makeFloat("3.14"));
	value = defGetString(e3, &need_free);
	assert_false(need_free);

	/* case: T_TypeName expected value: true */
	need_free = false;
	TypeName   *tName = makeNode(TypeName);
	tName->names = list_make2(makeString("pg_catalog"), makeString("unknown"));
	tName->typmod = -1;
	tName->location = -1;
	DefElem *e4 = makeDefElem("def_typename", (Node *) tName);
	value = defGetString(e4, &need_free);
	assert_true(need_free);

	/* case: T_List expected value: true */
	need_free = false;
	List *list = NIL;
	list = lappend(list, makeString("str1"));
	list = lappend(list, makeString("str2"));
	DefElem *e5 = makeDefElem("def_list", (Node *) list);
	value = defGetString(e5, &need_free);
	assert_true(need_free);

}

/* ==================== main ==================== */
int
main(int argc, char* argv[])
{
	cmockery_parse_arguments(argc, argv);

	const UnitTest tests[] = {
			unit_test(test__DefGetString_NeedFreeFlag)
	};
	return run_tests(tests);
}


l n = ffi.new('int [1]')
  local d = ffi.new('int [1]')
  local h = ffi.new('int [1]')
  local w = ffi.new('int [1]')
  oc.cpu.octree_split_grid_idx_cpu(self.grid, grid_idx, n,d,h,w)
  d[0] = 8 * d[0]
  h[0] = 8 * h[0]
  w[0] = 8 * w[0]

  local depth = oc.cpu.depth_from_bit_idx_cpu(bit_idx)
  if depth == 1 then
    oc.cpu.bdhw_from_idx_l1_cpu(bit_idx, d,h,w)
  elseif depth == 2 then
    oc.cpu.bdhw_from_idx_l2_cpu(bit_idx, d,h,w)
  elseif depth == 3 then
    oc.cpu.bdhw_from_idx_l3_cpu(bit_idx, d,h,w)
  end

  return n[0]+1, d[0]+1 ,h[0]+1 ,w[0]+1
end

function FloatOctree:tree_bit_string(grid_idx)
  local grid_idx = grid_idx or error('no grid_idx specified')

  local function bool2int(b)
    if b then return 1 else return 0 end
  end

  local str = bool2int(self:tree_isset_bit(grid_idx, 1)) .. ' '
  for i = 2, 9 do
    str = str .. bool2int(self:tree_isset_bit(grid_idx, i))
  end
  for c = 2, 9 do
    str = str .. ' '
    local cidx = (c - 1) * 8 + 2
    for i = cidx, cidx + 7 do
      str = str .. bool2int(self:tree_isset_bit(grid_idx, i))
    end
  end
  return str
end

function FloatOctree:print()
  oc.cpu.octree_print_cpu(self.grid)
end

-- used mainly for finite differences
-- can be avoided by overloading functions directly on octree that are needed in fd
function FloatOctree:data()
  local tensor = torch.FloatTensor()
  oc.torch_cpu.THFloatStorage_free(tensor:cdata().storage)
  tensor:cdata().storage = oc.torch_cpu.octree_data_torch_cpu(self.grid)
  tensor:cdata().size = oc.torch_cpu.THAlloc(ffi.sizeof('long') * 1)
  tensor:cdata().size[0] = tensor:cdata().storage.size
  tensor:cdata().stride = oc.torch_cpu.THAlloc(ffi.sizeof('long') * 1)
  tensor:cdata().stride[0] = 1
  tensor:cdata().nDimension = 1
  tensor:cdata().storageOffset = 0
  tensor:cdata().refcount = 1
  return tensor
end

function FloatOctree:cpy_data(tensor)
  if self.grid.feature_size * self.grid.n_leafs ~= tensor:nElement() then
    error('number of elements does not match: '..(self.grid.feature_size * self.grid.n_leafs)..' vs '..tensor:nElement())
  end
  if not tensor:isContiguous() then error('tensor is not contiguous') end
  -- for idx = 0, self.grid.n_leafs - 1 do
  --   self.grid.data[idx] = tensor:data()[idx]
  -- end
  ffi.copy(self.grid.data, tensor:data(), self.grid.feature_size * self.grid.n_leafs * ffi.sizeof('float'))
end

function FloatOctree:cuda(other)
  local grid = other or oc.CudaOctree()
  oc.gpu.octree_to_gpu(self.


list>li>a:hover:before{width:2px}.menu-min .nav-list>li:hover>a{color:#1963aa}.menu-min .nav-list>li:hover>a>.menu-text{display:block}.menu-min .nav-list>li.active>a>.menu-text{border-left-color:#1963aa}.menu-min .nav-list>li.open>a{background-color:#fafafa;color:#585858}.menu-min .nav-list>li.open.active>a{background-color:#fff}.menu-min .nav-list>li.open:hover>a{color:#1963aa}.menu-min .nav-list>li.active>a{color:#2b7dbc}.menu-min .nav-list>li.active>a:after{border-width:10px 6px;top:8px}.menu-min .nav-list>li.active.open>a:after{display:block}.menu-min .nav-list>li.active.open li.active>a:after{display:none}.menu-min .nav-list>li>.submenu{background:#fff;position:absolute;z-index:120;left:42px;top:-2px;width:176px;border:1px solid #ccc;-webkit-box-shadow:2px 1px 2px 0 rgba(0,0,0,0.2);box-shadow:2px 1px 2px 0 rgba(0,0,0,0.2);padding-top:40px;padding-bottom:2px;display:none!important}.menu-min .nav-list>li>.submenu:before{display:none}.menu-min .nav-list>li>.submenu li:before{display:none}.menu-min .nav-list>li>.submenu li>a{margin-left:0;padding-left:24px}.menu-min .nav-list>li>.submenu li>a>[class*="icon-"]:first-child{left:4px}.menu-min .nav-list>li:hover>.submenu{display:block!important}.menu-min .nav-list>li.active>.submenu{border-left-color:#2b7dbc}.menu-min .sidebar-shortcuts{position:relative}.menu-min .sidebar-shortcuts-mini{display:block}.menu-min .sidebar-shortcuts-large{display:none;position:absolute;z-index:20;top:-1px;left:42px;width:182px;padding:0 2px 1px;background-color:#fff;-webkit-box-shadow:2px 1px 2px 0 rgba(0,0,0,0.2);box-shadow:2px 1px 2px 0 rgba(0,0,0,0.2);border:1px solid #ccc}.menu-min .sidebar-shortcuts:hover .sidebar-shortcuts-large{display:block}.menu-min .sidebar-collapse:before{left:5px;right:5px}.menu-min .sidebar-collapse>[class*="icon-"]{font-size:13px;padding:0 4px;line-height:15px;border-width:1px;border-color:#aeaeae}.menu-min .nav-list>li>.submenu li>.submenu>li>a{margin-left:0;padding-left:30px}.menu-min .nav-list>li>.submenu li>.submenu>li>.submenu>li>a{margin-left:0;padding-left:45px}.menu-min .nav-list>li>.submenu li.active>a:after{display:none}.menu-min .nav-list li.active.open>.submenu>li.active>a:after{display:none}.menu-toggler{display:none}@media only screen and (max-width:991px){.sidebar:before{display:none}.sidebar{display:none;float:none;position:absolute;z-index:999;left:0;bottom:auto;top:auto!important;margin-top:40px;border:1px solid #CCC;border-left-width:0;box-shadow:2px 1px 2px 0 rgba(0,0,0,0.2)}.sidebar.display{display:block}.menu-toggler{display:inline-block;position:absolute;left:0