@ic10/metadata 0.0.0 → 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (5) hide show
  1. package/CHANGELOG.md +6 -0
  2. package/dist/locals/instructions.d.ts +326 -326
  3. package/dist/locals/instructions.js +326 -326
  4. package/package.json +29 -17
  5. package/tsconfig.json +18 -0
package/dist/locals/instructions.d.ts CHANGED
@@ -1,980 +1,980 @@
1
1
  declare const data: {
2
2
  readonly "#": {
3
3
  readonly desc: {
4
- readonly en: "any characters on line after this ignored";
5
- readonly zh: "此行中该符号之后的所有字符都会被忽略";
4
+ readonly "en-us": "any characters on line after this ignored";
5
+ readonly "zh-hans": "此行中该符号之后的所有字符都会被忽略";
6
6
  };
7
7
  };
8
8
  readonly abs: {
9
9
  readonly desc: {
10
- readonly en: "Compares the absolute value of a, and stores it in register (r?)";
11
- readonly zh: "比较a的绝对值，并保存在寄存器(r?)中";
10
+ readonly "en-us": "Compares the absolute value of a, and stores it in register (r?)";
11
+ readonly "zh-hans": "比较a的绝对值，并保存在寄存器(r?)中";
12
12
  };
13
13
  };
14
14
  readonly acos: {
15
15
  readonly desc: {
16
- readonly en: "Calculates the cosine value of the arc length a, and stores it in register (r?)";
17
- readonly zh: "计算弧长为a的余弦值，并保存在寄存器(r?)中";
16
+ readonly "en-us": "Calculates the cosine value of the arc length a, and stores it in register (r?)";
17
+ readonly "zh-hans": "计算弧长为a的余弦值，并保存在寄存器(r?)中";
18
18
  };
19
19
  };
20
20
  readonly add: {
21
21
  readonly desc: {
22
- readonly en: "Calculates the result of a + b and stores it in register (r?)";
23
- readonly zh: "计算a+b的结果并保存在寄存器(r?)中";
22
+ readonly "en-us": "Calculates the result of a + b and stores it in register (r?)";
23
+ readonly "zh-hans": "计算a+b的结果并保存在寄存器(r?)中";
24
24
  };
25
25
  };
26
26
  readonly alias: {
27
27
  readonly desc: {
28
- readonly en: "Assigns a label (str) as an alias for a register (r?) or device (d?). Device aliases will also affect the content displayed on IC package pins.";
29
- readonly zh: "使用别名(alias)为寄存器(r?)或设备(d?)指定一个标签(str)，设备别名也会影响IC封装引脚上显示的内容";
28
+ readonly "en-us": "Assigns a label (str) as an alias for a register (r?) or device (d?). Device aliases will also affect the content displayed on IC package pins.";
29
+ readonly "zh-hans": "使用别名(alias)为寄存器(r?)或设备(d?)指定一个标签(str)，设备别名也会影响IC封装引脚上显示的内容";
30
30
  };
31
31
  };
32
32
  readonly and: {
33
33
  readonly desc: {
34
- readonly en: "Performs a bitwise AND operation on the binary representations of two values. Each bit in the result is determined by the corresponding bits of the input values: if both input bits are 1, the result bit is 1; otherwise, the result bit is 0.";
35
- readonly zh: "对两个数值的二进制表示形式执行按位AND(与)运算。结果中的每个位都是通过计算输入值的相应二进制位来确定的。如果输入值中的两个位均为1，则结果位为1；否则，结果位为0";
34
+ readonly "en-us": "Performs a bitwise AND operation on the binary representations of two values. Each bit in the result is determined by the corresponding bits of the input values: if both input bits are 1, the result bit is 1; otherwise, the result bit is 0.";
35
+ readonly "zh-hans": "对两个数值的二进制表示形式执行按位AND(与)运算。结果中的每个位都是通过计算输入值的相应二进制位来确定的。如果输入值中的两个位均为1，则结果位为1；否则，结果位为0";
36
36
  };
37
37
  };
38
38
  readonly asin: {
39
39
  readonly desc: {
40
- readonly en: "Arcsine function: calculates the radian value of the angle whose sine is a, and stores the result in register (r?)";
41
- readonly zh: "反正弦函数，计算正弦值为a的弧长值，并保存在寄存器(r?)中";
40
+ readonly "en-us": "Arcsine function: calculates the radian value of the angle whose sine is a, and stores the result in register (r?)";
41
+ readonly "zh-hans": "反正弦函数，计算正弦值为a的弧长值，并保存在寄存器(r?)中";
42
42
  };
43
43
  };
44
44
  readonly atan: {
45
45
  readonly desc: {
46
- readonly en: "Arctangent function: calculates the radian value of the angle whose tangent is a, and stores the result in register (r?)";
47
- readonly zh: "反正切函数，计算正切值为a的弧长值，并保存在寄存器(r?)中";
46
+ readonly "en-us": "Arctangent function: calculates the radian value of the angle whose tangent is a, and stores the result in register (r?)";
47
+ readonly "zh-hans": "反正切函数，计算正切值为a的弧长值，并保存在寄存器(r?)中";
48
48
  };
49
49
  };
50
50
  readonly atan2: {
51
51
  readonly desc: {
52
- readonly en: "Advanced arctangent function atan2: calculates the radian value of the angle represented by parameters a (y) and b (x), and stores the result in register (r?)";
53
- readonly zh: "高级反正切函数atan2，计算两个参数a(y)和b(x)所代表的正切值的弧长，并保存在寄存器(r?)中";
52
+ readonly "en-us": "Advanced arctangent function atan2: calculates the radian value of the angle represented by parameters a (y) and b (x), and stores the result in register (r?)";
53
+ readonly "zh-hans": "高级反正切函数atan2，计算两个参数a(y)和b(x)所代表的正切值的弧长，并保存在寄存器(r?)中";
54
54
  };
55
55
  };
56
56
  readonly bap: {
57
57
  readonly desc: {
58
- readonly en: "Jumps to line number d when abs(a-b) <= max(c * max(abs(a), abs(b)), float.epsilon * 8)";
59
- readonly zh: "当符合abs(a-b)<=max(c*max(abs(a), abs(b)), float.epsilon*8)时，则跳转到代码行号d";
58
+ readonly "en-us": "Jumps to line number d when abs(a-b) <= max(c * max(abs(a), abs(b)), float.epsilon * 8)";
59
+ readonly "zh-hans": "当符合abs(a-b)<=max(c*max(abs(a), abs(b)), float.epsilon*8)时，则跳转到代码行号d";
60
60
  };
61
61
  };
62
62
  readonly bapal: {
63
63
  readonly desc: {
64
- readonly en: "Jumps to line number c if a != b, and stores the line number before jumping plus 1 into register ra";
65
- readonly zh: "如果a!=b，则跳转到代码行号c行，并将跳转前的行号+1并储存在寄存器ra";
64
+ readonly "en-us": "Jumps to line number c if a != b, and stores the line number before jumping plus 1 into register ra";
65
+ readonly "zh-hans": "如果a!=b，则跳转到代码行号c行，并将跳转前的行号+1并储存在寄存器ra";
66
66
  };
67
67
  };
68
68
  readonly bapz: {
69
69
  readonly desc: {
70
- readonly en: "Jumps to line number c when abs(a) <= float.epsilon * 8";
71
- readonly zh: "当符合abs(a)<=float.epsilon*8，则跳转到代码行号c";
70
+ readonly "en-us": "Jumps to line number c when abs(a) <= float.epsilon * 8";
71
+ readonly "zh-hans": "当符合abs(a)<=float.epsilon*8，则跳转到代码行号c";
72
72
  };
73
73
  };
74
74
  readonly bapzal: {
75
75
  readonly desc: {
76
- readonly en: "Jumps to line number c when abs(a) <= float.epsilon * 8";
77
- readonly zh: "当符合abs(a)<=float.epsilon*8，则跳转到代码行号c";
76
+ readonly "en-us": "Jumps to line number c when abs(a) <= float.epsilon * 8";
77
+ readonly "zh-hans": "当符合abs(a)<=float.epsilon*8，则跳转到代码行号c";
78
78
  };
79
79
  };
80
80
  readonly bdns: {
81
81
  readonly desc: {
82
- readonly en: "Jumps to line number a if the device (d) is invalid";
83
- readonly zh: "如果设备(d)无效，则跳转到代码行号a";
82
+ readonly "en-us": "Jumps to line number a if the device (d) is invalid";
83
+ readonly "zh-hans": "如果设备(d)无效，则跳转到代码行号a";
84
84
  };
85
85
  };
86
86
  readonly bdnsal: {
87
87
  readonly desc: {
88
- readonly en: "Jumps to line number a if the device (d) is invalid, and stores the line number before jumping plus 1 into register ra";
89
- readonly zh: "如果设备(d)无效，则跳转到代码行号a，并将跳转前的行号+1并储存在寄存器ra";
88
+ readonly "en-us": "Jumps to line number a if the device (d) is invalid, and stores the line number before jumping plus 1 into register ra";
89
+ readonly "zh-hans": "如果设备(d)无效，则跳转到代码行号a，并将跳转前的行号+1并储存在寄存器ra";
90
90
  };
91
91
  };
92
92
  readonly bdnvl: {
93
93
  readonly desc: {
94
- readonly en: "Jumps to line a if the specified device is invalid for read instructions of the specified logic type";
95
- readonly zh: "如果所提供的设备对于所提供逻辑类型的读取指令无效，则跳转到行a";
94
+ readonly "en-us": "Jumps to line a if the specified device is invalid for read instructions of the specified logic type";
95
+ readonly "zh-hans": "如果所提供的设备对于所提供逻辑类型的读取指令无效，则跳转到行a";
96
96
  };
97
97
  };
98
98
  readonly bdnvs: {
99
99
  readonly desc: {
100
- readonly en: "Jumps to line a if the specified device is invalid for write instructions of the specified logic type";
101
- readonly zh: "如果所提供的设备对于所提供逻辑类型的写入指令无效，则跳转到行a";
100
+ readonly "en-us": "Jumps to line a if the specified device is invalid for write instructions of the specified logic type";
101
+ readonly "zh-hans": "如果所提供的设备对于所提供逻辑类型的写入指令无效，则跳转到行a";
102
102
  };
103
103
  };
104
104
  readonly bdse: {
105
105
  readonly desc: {
106
- readonly en: "Jumps to line number a if the device (d) is valid";
107
- readonly zh: "如果设备(d)有效，则跳转到代码行号a";
106
+ readonly "en-us": "Jumps to line number a if the device (d) is valid";
107
+ readonly "zh-hans": "如果设备(d)有效，则跳转到代码行号a";
108
108
  };
109
109
  };
110
110
  readonly bdseal: {
111
111
  readonly desc: {
112
- readonly en: "Jumps to line number a if the device (d) is valid, and stores the line number before jumping plus 1 into register ra";
113
- readonly zh: "如果设备(d)有效，则跳转到代码行号a，并将跳转前的行号+1并储存在寄存器ra";
112
+ readonly "en-us": "Jumps to line number a if the device (d) is valid, and stores the line number before jumping plus 1 into register ra";
113
+ readonly "zh-hans": "如果设备(d)有效，则跳转到代码行号a，并将跳转前的行号+1并储存在寄存器ra";
114
114
  };
115
115
  };
116
116
  readonly beq: {
117
117
  readonly desc: {
118
- readonly en: "Jumps to line number c if a == b";
119
- readonly zh: "如果a==b，则跳转到代码行号c";
118
+ readonly "en-us": "Jumps to line number c if a == b";
119
+ readonly "zh-hans": "如果a==b，则跳转到代码行号c";
120
120
  };
121
121
  };
122
122
  readonly beqal: {
123
123
  readonly desc: {
124
- readonly en: "Jumps to line number c if a == b, and stores the line number before jumping plus 1 into register ra";
125
- readonly zh: "如果a==b，则跳转到代码行号c行，并将跳转前的行号+1并储存在寄存器ra";
124
+ readonly "en-us": "Jumps to line number c if a == b, and stores the line number before jumping plus 1 into register ra";
125
+ readonly "zh-hans": "如果a==b，则跳转到代码行号c行，并将跳转前的行号+1并储存在寄存器ra";
126
126
  };
127
127
  };
128
128
  readonly beqz: {
129
129
  readonly desc: {
130
- readonly en: "Jumps to line number b if a == 0";
131
- readonly zh: "如果a==0，则跳转到代码行号b";
130
+ readonly "en-us": "Jumps to line number b if a == 0";
131
+ readonly "zh-hans": "如果a==0，则跳转到代码行号b";
132
132
  };
133
133
  };
134
134
  readonly beqzal: {
135
135
  readonly desc: {
136
- readonly en: "Jumps to line number b if a == 0, and stores the line number before jumping plus 1 into register ra";
137
- readonly zh: "如果a==0，则跳转到代码行号b行，并将跳转前的行号+1并储存在寄存器ra";
136
+ readonly "en-us": "Jumps to line number b if a == 0, and stores the line number before jumping plus 1 into register ra";
137
+ readonly "zh-hans": "如果a==0，则跳转到代码行号b行，并将跳转前的行号+1并储存在寄存器ra";
138
138
  };
139
139
  };
140
140
  readonly bge: {
141
141
  readonly desc: {
142
- readonly en: "Jumps to line number c if a >= b";
143
- readonly zh: "如果a>=b，则跳转到代码行号c";
142
+ readonly "en-us": "Jumps to line number c if a >= b";
143
+ readonly "zh-hans": "如果a>=b，则跳转到代码行号c";
144
144
  };
145
145
  };
146
146
  readonly bgeal: {
147
147
  readonly desc: {
148
- readonly en: "Jumps to line number c if a >= b, and stores the line number before jumping plus 1 into register ra";
149
- readonly zh: "如果a>=b，则跳转到代码行号c行，并将跳转前的行号+1并储存在寄存器ra";
148
+ readonly "en-us": "Jumps to line number c if a >= b, and stores the line number before jumping plus 1 into register ra";
149
+ readonly "zh-hans": "如果a>=b，则跳转到代码行号c行，并将跳转前的行号+1并储存在寄存器ra";
150
150
  };
151
151
  };
152
152
  readonly bgez: {
153
153
  readonly desc: {
154
- readonly en: "Jumps to line number b if a >= 0";
155
- readonly zh: "如果a>=0，则跳转到代码行号b";
154
+ readonly "en-us": "Jumps to line number b if a >= 0";
155
+ readonly "zh-hans": "如果a>=0，则跳转到代码行号b";
156
156
  };
157
157
  };
158
158
  readonly bgezal: {
159
159
  readonly desc: {
160
- readonly en: "Jumps to line number b if a >= 0, and stores the line number before jumping plus 1 into register ra";
161
- readonly zh: "如果a>=0，则跳转到代码行号b行，并将跳转前的行号+1并储存在寄存器ra";
160
+ readonly "en-us": "Jumps to line number b if a >= 0, and stores the line number before jumping plus 1 into register ra";
161
+ readonly "zh-hans": "如果a>=0，则跳转到代码行号b行，并将跳转前的行号+1并储存在寄存器ra";
162
162
  };
163
163
  };
164
164
  readonly bgt: {
165
165
  readonly desc: {
166
- readonly en: "Jumps to line number c if a > b";
167
- readonly zh: "如果a>b，则跳转到代码行号c";
166
+ readonly "en-us": "Jumps to line number c if a > b";
167
+ readonly "zh-hans": "如果a>b，则跳转到代码行号c";
168
168
  };
169
169
  };
170
170
  readonly bgtal: {
171
171
  readonly desc: {
172
- readonly en: "Jumps to line number c if a > b, and stores the line number before jumping plus 1 into register ra";
173
- readonly zh: "如果a>b，则跳转到代码行号c行，并将跳转前的行号+1并储存在寄存器ra";
172
+ readonly "en-us": "Jumps to line number c if a > b, and stores the line number before jumping plus 1 into register ra";
173
+ readonly "zh-hans": "如果a>b，则跳转到代码行号c行，并将跳转前的行号+1并储存在寄存器ra";
174
174
  };
175
175
  };
176
176
  readonly bgtz: {
177
177
  readonly desc: {
178
- readonly en: "Jumps to line number b if a > 0";
179
- readonly zh: "如果a>0，则跳转到代码行号b";
178
+ readonly "en-us": "Jumps to line number b if a > 0";
179
+ readonly "zh-hans": "如果a>0，则跳转到代码行号b";
180
180
  };
181
181
  };
182
182
  readonly bgtzal: {
183
183
  readonly desc: {
184
- readonly en: "Jumps to line number b if a > 0, and stores the line number before jumping plus 1 into register ra";
185
- readonly zh: "如果a>0，则跳转到代码行号b行，并将跳转前的行号+1并储存在寄存器ra";
184
+ readonly "en-us": "Jumps to line number b if a > 0, and stores the line number before jumping plus 1 into register ra";
185
+ readonly "zh-hans": "如果a>0，则跳转到代码行号b行，并将跳转前的行号+1并储存在寄存器ra";
186
186
  };
187
187
  };
188
188
  readonly binary_number: {
189
189
  readonly desc: {
190
- readonly en: "any valid binary numbers (0 or 1) will be parsed together as a binary value. You can use underscores to help with readability, but they have no functional use. As an example, %1111 or %11_11 will parse as 15.";
191
- readonly zh: "任意有效二进制数字（0 或 1）将被共同解析为一个二进制数值。可以使用下划线提升可读性，但下划线无实际功能作用。例如，%1111 或 %11_11 会被解析为 15。";
190
+ readonly "en-us": "any valid binary numbers (0 or 1) will be parsed together as a binary value. You can use underscores to help with readability, but they have no functional use. As an example, %1111 or %11_11 will parse as 15.";
191
+ readonly "zh-hans": "任意有效二进制数字（0 或 1）将被共同解析为一个二进制数值。可以使用下划线提升可读性，但下划线无实际功能作用。例如，%1111 或 %11_11 会被解析为 15。";
192
192
  };
193
193
  };
194
194
  readonly ble: {
195
195
  readonly desc: {
196
- readonly en: "Jumps to line number c if a <= b";
197
- readonly zh: "如果a<=b，则跳转到代码行号c";
196
+ readonly "en-us": "Jumps to line number c if a <= b";
197
+ readonly "zh-hans": "如果a<=b，则跳转到代码行号c";
198
198
  };
199
199
  };
200
200
  readonly bleal: {
201
201
  readonly desc: {
202
- readonly en: "Jumps to line number c if a <= b, and stores the line number before jumping plus 1 into register ra";
203
- readonly zh: "如果a<=b，则跳转到代码行号c行，并将跳转前的行号+1并储存在寄存器ra";
202
+ readonly "en-us": "Jumps to line number c if a <= b, and stores the line number before jumping plus 1 into register ra";
203
+ readonly "zh-hans": "如果a<=b，则跳转到代码行号c行，并将跳转前的行号+1并储存在寄存器ra";
204
204
  };
205
205
  };
206
206
  readonly blez: {
207
207
  readonly desc: {
208
- readonly en: "Jumps to line number b if a <= 0";
209
- readonly zh: "如果a<=0，则跳转到代码行号b";
208
+ readonly "en-us": "Jumps to line number b if a <= 0";
209
+ readonly "zh-hans": "如果a<=0，则跳转到代码行号b";
210
210
  };
211
211
  };
212
212
  readonly blezal: {
213
213
  readonly desc: {
214
- readonly en: "Jumps to line number b if a <= 0, and stores the line number before jumping plus 1 into register ra";
215
- readonly zh: "如果a<=0，则跳转到代码行号b行，并将跳转前的行号+1并储存在寄存器ra";
214
+ readonly "en-us": "Jumps to line number b if a <= 0, and stores the line number before jumping plus 1 into register ra";
215
+ readonly "zh-hans": "如果a<=0，则跳转到代码行号b行，并将跳转前的行号+1并储存在寄存器ra";
216
216
  };
217
217
  };
218
218
  readonly blt: {
219
219
  readonly desc: {
220
- readonly en: "Jumps to line number c if a < b";
221
- readonly zh: "如果a<b，则跳转到代码行号c";
220
+ readonly "en-us": "Jumps to line number c if a < b";
221
+ readonly "zh-hans": "如果a<b，则跳转到代码行号c";
222
222
  };
223
223
  };
224
224
  readonly bltal: {
225
225
  readonly desc: {
226
- readonly en: "Jumps to line number c if a < b, and stores the line number before jumping plus 1 into register ra";
227
- readonly zh: "如果a<b，则跳转到代码行号c行，并将跳转前的行号+1并储存在寄存器ra";
226
+ readonly "en-us": "Jumps to line number c if a < b, and stores the line number before jumping plus 1 into register ra";
227
+ readonly "zh-hans": "如果a<b，则跳转到代码行号c行，并将跳转前的行号+1并储存在寄存器ra";
228
228
  };
229
229
  };
230
230
  readonly bltz: {
231
231
  readonly desc: {
232
- readonly en: "Jumps to line number b if a < 0";
233
- readonly zh: "如果a<0，则跳转到代码行号b";
232
+ readonly "en-us": "Jumps to line number b if a < 0";
233
+ readonly "zh-hans": "如果a<0，则跳转到代码行号b";
234
234
  };
235
235
  };
236
236
  readonly bltzal: {
237
237
  readonly desc: {
238
- readonly en: "Jumps to line number b if a < 0, and stores the line number before jumping plus 1 into register ra";
239
- readonly zh: "如果a<0，则跳转到代码行号b行，并将跳转前的行号+1并储存在寄存器ra";
238
+ readonly "en-us": "Jumps to line number b if a < 0, and stores the line number before jumping plus 1 into register ra";
239
+ readonly "zh-hans": "如果a<0，则跳转到代码行号b行，并将跳转前的行号+1并储存在寄存器ra";
240
240
  };
241
241
  };
242
242
  readonly bna: {
243
243
  readonly desc: {
244
- readonly en: "Jumps to line number d when abs(a-b) > max(c * max(abs(a), abs(b)), float.epsilon * 8)";
245
- readonly zh: "当符合abs(a-b)>max(c*max(abs(a), abs(b)), float.epsilon*8)时，则跳转到代码行号d";
244
+ readonly "en-us": "Jumps to line number d when abs(a-b) > max(c * max(abs(a), abs(b)), float.epsilon * 8)";
245
+ readonly "zh-hans": "当符合abs(a-b)>max(c*max(abs(a), abs(b)), float.epsilon*8)时，则跳转到代码行号d";
246
246
  };
247
247
  };
248
248
  readonly bnaal: {
249
249
  readonly desc: {
250
- readonly en: "Jumps to line number d when abs(a-b) > max(c * max(abs(a), abs(b)), float.epsilon * 8), and stores the line number before jumping plus 1 into register ra";
251
- readonly zh: "当符合abs(a-b)>max(c*max(abs(a), abs(b)), float.epsilon*8)时，则跳转到代码行号d行，并将跳转前的行号+1并储存在寄存器ra";
250
+ readonly "en-us": "Jumps to line number d when abs(a-b) > max(c * max(abs(a), abs(b)), float.epsilon * 8), and stores the line number before jumping plus 1 into register ra";
251
+ readonly "zh-hans": "当符合abs(a-b)>max(c*max(abs(a), abs(b)), float.epsilon*8)时，则跳转到代码行号d行，并将跳转前的行号+1并储存在寄存器ra";
252
252
  };
253
253
  };
254
254
  readonly bnan: {
255
255
  readonly desc: {
256
- readonly en: "Jumps to line number b if a == NaN";
257
- readonly zh: "如果a==NaN，则跳转到代码行号b";
256
+ readonly "en-us": "Jumps to line number b if a == NaN";
257
+ readonly "zh-hans": "如果a==NaN，则跳转到代码行号b";
258
258
  };
259
259
  };
260
260
  readonly bnaz: {
261
261
  readonly desc: {
262
- readonly en: "Jumps to line number c when abs(a) > float.epsilon * 8";
263
- readonly zh: "当符合abs(a)>float.epsilon*8，则跳转到代码行号c";
262
+ readonly "en-us": "Jumps to line number c when abs(a) > float.epsilon * 8";
263
+ readonly "zh-hans": "当符合abs(a)>float.epsilon*8，则跳转到代码行号c";
264
264
  };
265
265
  };
266
266
  readonly bnazal: {
267
267
  readonly desc: {
268
- readonly en: "Jumps to line number c when abs(a) > float.epsilon * 8";
269
- readonly zh: "当符合abs(a)>float.epsilon*8，则跳转到代码行号c";
268
+ readonly "en-us": "Jumps to line number c when abs(a) > float.epsilon * 8";
269
+ readonly "zh-hans": "当符合abs(a)>float.epsilon*8，则跳转到代码行号c";
270
270
  };
271
271
  };
272
272
  readonly bne: {
273
273
  readonly desc: {
274
- readonly en: "Jumps to line number c if a != b";
275
- readonly zh: "如果a!=b，则跳转到代码行号c";
274
+ readonly "en-us": "Jumps to line number c if a != b";
275
+ readonly "zh-hans": "如果a!=b，则跳转到代码行号c";
276
276
  };
277
277
  };
278
278
  readonly bneal: {
279
279
  readonly desc: {
280
- readonly en: "Jumps to line number c if a != b, and stores the line number before jumping plus 1 into register ra";
281
- readonly zh: "如果a!=b，则跳转到代码行号c行，并将跳转前的行号+1并储存在寄存器ra";
280
+ readonly "en-us": "Jumps to line number c if a != b, and stores the line number before jumping plus 1 into register ra";
281
+ readonly "zh-hans": "如果a!=b，则跳转到代码行号c行，并将跳转前的行号+1并储存在寄存器ra";
282
282
  };
283
283
  };
284
284
  readonly bnez: {
285
285
  readonly desc: {
286
- readonly en: "Jumps to line number b if a != 0";
287
- readonly zh: "如果a!=0，则跳转到代码行号b";
286
+ readonly "en-us": "Jumps to line number b if a != 0";
287
+ readonly "zh-hans": "如果a!=0，则跳转到代码行号b";
288
288
  };
289
289
  };
290
290
  readonly bnezal: {
291
291
  readonly desc: {
292
- readonly en: "Jumps to line number b if a != 0, and stores the line number before jumping plus 1 into register ra";
293
- readonly zh: "如果a!=0，则跳转到代码行号b行，并将跳转前的行号+1并储存在寄存器ra";
292
+ readonly "en-us": "Jumps to line number b if a != 0, and stores the line number before jumping plus 1 into register ra";
293
+ readonly "zh-hans": "如果a!=0，则跳转到代码行号b行，并将跳转前的行号+1并储存在寄存器ra";
294
294
  };
295
295
  };
296
296
  readonly brap: {
297
297
  readonly desc: {
298
- readonly en: "Jumps to line (current line + d) when abs(a-b) <= max(c * max(abs(a), abs(b)), float.epsilon * 8)";
299
- readonly zh: "当符合abs(a-b)<=max(c*max(abs(a), abs(b)), float.epsilon*8)时，则跳转到代码行号(当前行号+d)行";
298
+ readonly "en-us": "Jumps to line (current line + d) when abs(a-b) <= max(c * max(abs(a), abs(b)), float.epsilon * 8)";
299
+ readonly "zh-hans": "当符合abs(a-b)<=max(c*max(abs(a), abs(b)), float.epsilon*8)时，则跳转到代码行号(当前行号+d)行";
300
300
  };
301
301
  };
302
302
  readonly brapz: {
303
303
  readonly desc: {
304
- readonly en: "Jumps to line (current line + c) when abs(a) <= float.epsilon * 8";
305
- readonly zh: "当符合abs(a)<=float.epsilon*8，则跳转到代码行号(当前行号+c)行";
304
+ readonly "en-us": "Jumps to line (current line + c) when abs(a) <= float.epsilon * 8";
305
+ readonly "zh-hans": "当符合abs(a)<=float.epsilon*8，则跳转到代码行号(当前行号+c)行";
306
306
  };
307
307
  };
308
308
  readonly brdns: {
309
309
  readonly desc: {
310
- readonly en: "Jumps to line (current line + a) if the device (d) is invalid";
311
- readonly zh: "如果设备(d)无效，则跳转到代码行号(当前行号+a)行";
310
+ readonly "en-us": "Jumps to line (current line + a) if the device (d) is invalid";
311
+ readonly "zh-hans": "如果设备(d)无效，则跳转到代码行号(当前行号+a)行";
312
312
  };
313
313
  };
314
314
  readonly brdse: {
315
315
  readonly desc: {
316
- readonly en: "Jumps to line (current line + a) if the device (d) is valid";
317
- readonly zh: "如果设备(d)有效，则跳转到代码行号(当前行号+a)行";
316
+ readonly "en-us": "Jumps to line (current line + a) if the device (d) is valid";
317
+ readonly "zh-hans": "如果设备(d)有效，则跳转到代码行号(当前行号+a)行";
318
318
  };
319
319
  };
320
320
  readonly breq: {
321
321
  readonly desc: {
322
- readonly en: "Jumps to line (current line + c) if a == b";
323
- readonly zh: "如果a==b，则跳转到代码行号(当前行号+c)行";
322
+ readonly "en-us": "Jumps to line (current line + c) if a == b";
323
+ readonly "zh-hans": "如果a==b，则跳转到代码行号(当前行号+c)行";
324
324
  };
325
325
  };
326
326
  readonly breqz: {
327
327
  readonly desc: {
328
- readonly en: "Jumps to line (current line + b) if a == 0";
329
- readonly zh: "如果a==0，则跳转到代码行号(当前行号+b)行";
328
+ readonly "en-us": "Jumps to line (current line + b) if a == 0";
329
+ readonly "zh-hans": "如果a==0，则跳转到代码行号(当前行号+b)行";
330
330
  };
331
331
  };
332
332
  readonly brge: {
333
333
  readonly desc: {
334
- readonly en: "Jumps to line (current line + c) if a >= b";
335
- readonly zh: "如果a>=b，则跳转到代码行号(当前行号+c)行";
334
+ readonly "en-us": "Jumps to line (current line + c) if a >= b";
335
+ readonly "zh-hans": "如果a>=b，则跳转到代码行号(当前行号+c)行";
336
336
  };
337
337
  };
338
338
  readonly brgez: {
339
339
  readonly desc: {
340
- readonly en: "Jumps to line (current line + b) if a >= 0";
341
- readonly zh: "如果a>=0，则跳转到代码行号(当前行号+b)行";
340
+ readonly "en-us": "Jumps to line (current line + b) if a >= 0";
341
+ readonly "zh-hans": "如果a>=0，则跳转到代码行号(当前行号+b)行";
342
342
  };
343
343
  };
344
344
  readonly brgt: {
345
345
  readonly desc: {
346
- readonly en: "Jumps to line (current line + c) if a > b";
347
- readonly zh: "如果a>b，则跳转到代码行号(当前行号+c)行";
346
+ readonly "en-us": "Jumps to line (current line + c) if a > b";
347
+ readonly "zh-hans": "如果a>b，则跳转到代码行号(当前行号+c)行";
348
348
  };
349
349
  };
350
350
  readonly brgtz: {
351
351
  readonly desc: {
352
- readonly en: "Jumps to line (current line + b) if a > 0";
353
- readonly zh: "如果a>0，则跳转到代码行号(当前行号+b)行";
352
+ readonly "en-us": "Jumps to line (current line + b) if a > 0";
353
+ readonly "zh-hans": "如果a>0，则跳转到代码行号(当前行号+b)行";
354
354
  };
355
355
  };
356
356
  readonly brle: {
357
357
  readonly desc: {
358
- readonly en: "Jumps to line (current line + c) if a <= b";
359
- readonly zh: "如果a<=b，则跳转到代码行号(当前行号+c)行";
358
+ readonly "en-us": "Jumps to line (current line + c) if a <= b";
359
+ readonly "zh-hans": "如果a<=b，则跳转到代码行号(当前行号+c)行";
360
360
  };
361
361
  };
362
362
  readonly brlez: {
363
363
  readonly desc: {
364
- readonly en: "Jumps to line (current line + b) if a <= 0";
365
- readonly zh: "如果a<=0，则跳转到代码行号(当前行号+b)行";
364
+ readonly "en-us": "Jumps to line (current line + b) if a <= 0";
365
+ readonly "zh-hans": "如果a<=0，则跳转到代码行号(当前行号+b)行";
366
366
  };
367
367
  };
368
368
  readonly brlt: {
369
369
  readonly desc: {
370
- readonly en: "Jumps to line (current line + c) if a < b";
371
- readonly zh: "如果a<b，则跳转到代码行号(当前行号+c)行";
370
+ readonly "en-us": "Jumps to line (current line + c) if a < b";
371
+ readonly "zh-hans": "如果a<b，则跳转到代码行号(当前行号+c)行";
372
372
  };
373
373
  };
374
374
  readonly brltz: {
375
375
  readonly desc: {
376
- readonly en: "Jumps to line (current line + b) if a < 0";
377
- readonly zh: "如果a<0，则跳转到代码行号(当前行号+b)行";
376
+ readonly "en-us": "Jumps to line (current line + b) if a < 0";
377
+ readonly "zh-hans": "如果a<0，则跳转到代码行号(当前行号+b)行";
378
378
  };
379
379
  };
380
380
  readonly brna: {
381
381
  readonly desc: {
382
- readonly en: "Jumps to line (current line + d) when abs(a-b) > max(c * max(abs(a), abs(b)), float.epsilon * 8)";
383
- readonly zh: "当符合abs(a-b)>max(c*max(abs(a), abs(b)), float.epsilon*8)时，则跳转到代码行号(当前行号+d)行";
382
+ readonly "en-us": "Jumps to line (current line + d) when abs(a-b) > max(c * max(abs(a), abs(b)), float.epsilon * 8)";
383
+ readonly "zh-hans": "当符合abs(a-b)>max(c*max(abs(a), abs(b)), float.epsilon*8)时，则跳转到代码行号(当前行号+d)行";
384
384
  };
385
385
  };
386
386
  readonly brnan: {
387
387
  readonly desc: {
388
- readonly en: "Jumps to line (current line + b) if a == NaN";
389
- readonly zh: "如果a==NaN，则跳转到代码行号(当前行号+b)行";
388
+ readonly "en-us": "Jumps to line (current line + b) if a == NaN";
389
+ readonly "zh-hans": "如果a==NaN，则跳转到代码行号(当前行号+b)行";
390
390
  };
391
391
  };
392
392
  readonly brnaz: {
393
393
  readonly desc: {
394
- readonly en: "Jumps to line (current line + c) when abs(a) > float.epsilon * 8";
395
- readonly zh: "当符合abs(a)>float.epsilon*8，则跳转到代码行号(当前行号+c)行";
394
+ readonly "en-us": "Jumps to line (current line + c) when abs(a) > float.epsilon * 8";
395
+ readonly "zh-hans": "当符合abs(a)>float.epsilon*8，则跳转到代码行号(当前行号+c)行";
396
396
  };
397
397
  };
398
398
  readonly brne: {
399
399
  readonly desc: {
400
- readonly en: "Jumps to line (current line + c) if a != b";
401
- readonly zh: "如果a!=b，则跳转到代码行号(当前行号+c)行";
400
+ readonly "en-us": "Jumps to line (current line + c) if a != b";
401
+ readonly "zh-hans": "如果a!=b，则跳转到代码行号(当前行号+c)行";
402
402
  };
403
403
  };
404
404
  readonly brnez: {
405
405
  readonly desc: {
406
- readonly en: "Jumps to line (current line + b) if a != 0";
407
- readonly zh: "如果a!=0，则跳转到代码行号(当前行号+b)行";
406
+ readonly "en-us": "Jumps to line (current line + b) if a != 0";
407
+ readonly "zh-hans": "如果a!=0，则跳转到代码行号(当前行号+b)行";
408
408
  };
409
409
  };
410
410
  readonly ceil: {
411
411
  readonly desc: {
412
- readonly en: "Calculates the smallest integer greater than a, and stores it in register (r?)";
413
- readonly zh: "计算大于a的最小整数，并保存在寄存器(r?)中";
412
+ readonly "en-us": "Calculates the smallest integer greater than a, and stores it in register (r?)";
413
+ readonly "zh-hans": "计算大于a的最小整数，并保存在寄存器(r?)中";
414
414
  };
415
415
  };
416
416
  readonly clamp: {
417
417
  readonly desc: {
418
- readonly en: "Stores a clamped to the inclusive range [min, max] in the register provided.";
419
- readonly zh: "将a限制在闭区间[min, max]范围内，并将结果存入指定寄存器";
418
+ readonly "en-us": "Stores a clamped to the inclusive range [min, max] in the register provided.";
419
+ readonly "zh-hans": "将a限制在闭区间[min, max]范围内，并将结果存入指定寄存器";
420
420
  };
421
421
  };
422
422
  readonly clr: {
423
423
  readonly desc: {
424
- readonly en: "Clears the stack memory of the specified device";
425
- readonly zh: "清除指定设备的堆栈内存";
424
+ readonly "en-us": "Clears the stack memory of the specified device";
425
+ readonly "zh-hans": "清除指定设备的堆栈内存";
426
426
  };
427
427
  };
428
428
  readonly clrd: {
429
429
  readonly desc: {
430
- readonly en: "Locates a device by its ID and clears its stack memory";
431
- readonly zh: "通过设备ID定位设备并清除其堆栈内存";
430
+ readonly "en-us": "Locates a device by its ID and clears its stack memory";
431
+ readonly "zh-hans": "通过设备ID定位设备并清除其堆栈内存";
432
432
  };
433
433
  };
434
434
  readonly cos: {
435
435
  readonly desc: {
436
- readonly en: "Calculates the cosine value of the arc length a, and stores it in register (r?)";
437
- readonly zh: "计算弧长为a的余弦值，并保存在寄存器(r?)中";
436
+ readonly "en-us": "Calculates the cosine value of the arc length a, and stores it in register (r?)";
437
+ readonly "zh-hans": "计算弧长为a的余弦值，并保存在寄存器(r?)中";
438
438
  };
439
439
  };
440
440
  readonly define: {
441
441
  readonly desc: {
442
- readonly en: "Defines a label (str) for the specified value (num). All occurrences of the same label in the program will be replaced with this value";
443
- readonly zh: "为指定的值(num)定义一个标签(str)，程序中所有出现的同名标签都将被替换为该值";
442
+ readonly "en-us": "Defines a label (str) for the specified value (num). All occurrences of the same label in the program will be replaced with this value";
443
+ readonly "zh-hans": "为指定的值(num)定义一个标签(str)，程序中所有出现的同名标签都将被替换为该值";
444
444
  };
445
445
  };
446
446
  readonly deg2rad: {
447
447
  readonly desc: {
448
- readonly en: "Degrees to radians conversion constant. Value: 0.0174532923847437";
449
- readonly zh: "角度转弧度的换算常量，取值为 0.0174532923847437";
448
+ readonly "en-us": "Degrees to radians conversion constant. Value: 0.0174532923847437";
449
+ readonly "zh-hans": "角度转弧度的换算常量，取值为 0.0174532923847437";
450
450
  };
451
451
  };
452
452
  readonly div: {
453
453
  readonly desc: {
454
- readonly en: "Calculates the result of a / b and stores it in register (r?)";
455
- readonly zh: "计算a/b的结果并保存在寄存器(r?)中";
454
+ readonly "en-us": "Calculates the result of a / b and stores it in register (r?)";
455
+ readonly "zh-hans": "计算a/b的结果并保存在寄存器(r?)中";
456
456
  };
457
457
  };
458
458
  readonly epsilon: {
459
459
  readonly desc: {
460
- readonly en: "A constant representing the smallest positive subnormal > 0";
461
- readonly zh: "表示大于 0 的最小正次正规数的常量";
460
+ readonly "en-us": "A constant representing the smallest positive subnormal > 0";
461
+ readonly "zh-hans": "表示大于 0 的最小正次正规数的常量";
462
462
  };
463
463
  };
464
464
  readonly exp: {
465
465
  readonly desc: {
466
- readonly en: "Calculates the natural exponential exp(a) of a, and stores it in register (r?)";
467
- readonly zh: "计算a以自然常数为底的指数exp(a)，并保存在寄存器(r?)中";
466
+ readonly "en-us": "Calculates the natural exponential exp(a) of a, and stores it in register (r?)";
467
+ readonly "zh-hans": "计算a以自然常数为底的指数exp(a)，并保存在寄存器(r?)中";
468
468
  };
469
469
  };
470
470
  readonly ext: {
471
471
  readonly desc: {
472
- readonly en: "Extracts a segment of bits from a, starting at position b with length c, and places it into the provided register. The maximum valid payload length must not exceed 53 bits";
473
- readonly zh: "从a中提取一段比特值，起始位置为b，长度为c，并放入指定寄存器。最大有效载荷长度不得超过53位";
472
+ readonly "en-us": "Extracts a segment of bits from a, starting at position b with length c, and places it into the provided register. The maximum valid payload length must not exceed 53 bits";
473
+ readonly "zh-hans": "从a中提取一段比特值，起始位置为b，长度为c，并放入指定寄存器。最大有效载荷长度不得超过53位";
474
474
  };
475
475
  };
476
476
  readonly floor: {
477
477
  readonly desc: {
478
- readonly en: "Calculates the largest integer less than a, and stores it in register (r?)";
479
- readonly zh: "计算小于a的最大整数，并保存在寄存器(r?)中";
478
+ readonly "en-us": "Calculates the largest integer less than a, and stores it in register (r?)";
479
+ readonly "zh-hans": "计算小于a的最大整数，并保存在寄存器(r?)中";
480
480
  };
481
481
  };
482
482
  readonly get: {
483
483
  readonly desc: {
484
- readonly en: "Attempts to read the stack value at the specified address using the specified device, and stores it in register (r?)";
485
- readonly zh: "使用指定设备尝试读取指定地址的堆栈值，并存入寄存器(r?)";
484
+ readonly "en-us": "Attempts to read the stack value at the specified address using the specified device, and stores it in register (r?)";
485
+ readonly "zh-hans": "使用指定设备尝试读取指定地址的堆栈值，并存入寄存器(r?)";
486
486
  };
487
487
  };
488
488
  readonly hash: {
489
489
  readonly desc: {
490
- readonly en: "any text inside will be hashed to an integer before processing takes place. Use this to generate integer values for use wherever hashes are required.";
491
- readonly zh: "括号内的任意文本会在处理开始前被哈希为一个整数。可用于在需要哈希值的场景生成整数值。";
490
+ readonly "en-us": "any text inside will be hashed to an integer before processing takes place. Use this to generate integer values for use wherever hashes are required.";
491
+ readonly "zh-hans": "括号内的任意文本会在处理开始前被哈希为一个整数。可用于在需要哈希值的场景生成整数值。";
492
492
  };
493
493
  };
494
494
  readonly hash_number: {
495
495
  readonly desc: {
496
- readonly en: "any valid hex characters after this will be parsed together as a hex value. You can use underscores to help with readability, but they have no functional use. As an example, $F will parse as 15.";
497
- readonly zh: "此后的任意有效十六进制字符将被共同解析为一个十六进制数值。可以使用下划线提升可读性，但下划线无实际功能作用。例如，$F 会被解析为 15。";
496
+ readonly "en-us": "any valid hex characters after this will be parsed together as a hex value. You can use underscores to help with readability, but they have no functional use. As an example, $F will parse as 15.";
497
+ readonly "zh-hans": "此后的任意有效十六进制字符将被共同解析为一个十六进制数值。可以使用下划线提升可读性，但下划线无实际功能作用。例如，$F 会被解析为 15。";
498
498
  };
499
499
  };
500
500
  readonly hcf: {
501
501
  readonly desc: {
502
- readonly en: "Halt and catch fire. An early computer machine instruction that causes the CPU to perform cyclic addressing, continuously looping to read large amounts of data. If it addresses a non-existent memory address (catchfire state), it will lock up the computer (halt)";
503
- readonly zh: "Halt and catch fire，早期计算机的机器指令，作用是让CPU执行循环寻址操作，持续循环读取大量数据；若寻址到不存在的内存地址（Catchfire状态），将锁定计算机即挂起(Halt)";
502
+ readonly "en-us": "Halt and catch fire. An early computer machine instruction that causes the CPU to perform cyclic addressing, continuously looping to read large amounts of data. If it addresses a non-existent memory address (catchfire state), it will lock up the computer (halt)";
503
+ readonly "zh-hans": "Halt and catch fire，早期计算机的机器指令，作用是让CPU执行循环寻址操作，持续循环读取大量数据；若寻址到不存在的内存地址（Catchfire状态），将锁定计算机即挂起(Halt)";
504
504
  };
505
505
  };
506
506
  readonly ins: {
507
507
  readonly desc: {
508
- readonly en: "Inserts the bits of value a into the specified register, starting at position b with length c. The maximum valid payload length must not exceed 53 bits";
509
- readonly zh: "将a的值按比特位插入到指定寄存器中，起始位置为b，长度为c。最大有效载荷长度不得超过53位";
508
+ readonly "en-us": "Inserts the bits of value a into the specified register, starting at position b with length c. The maximum valid payload length must not exceed 53 bits";
509
+ readonly "zh-hans": "将a的值按比特位插入到指定寄存器中，起始位置为b，长度为c。最大有效载荷长度不得超过53位";
510
510
  };
511
511
  };
512
512
  readonly j: {
513
513
  readonly desc: {
514
- readonly en: "Jumps to code line number a";
515
- readonly zh: "跳转到代码行号a";
514
+ readonly "en-us": "Jumps to code line number a";
515
+ readonly "zh-hans": "跳转到代码行号a";
516
516
  };
517
517
  };
518
518
  readonly jal: {
519
519
  readonly desc: {
520
- readonly en: "Jumps to code line number a, and stores the line number before jumping plus 1 into register ra";
521
- readonly zh: "跳转到代码行号a，并将跳转前的行号+1储存在寄存器ra中";
520
+ readonly "en-us": "Jumps to code line number a, and stores the line number before jumping plus 1 into register ra";
521
+ readonly "zh-hans": "跳转到代码行号a，并将跳转前的行号+1储存在寄存器ra中";
522
522
  };
523
523
  };
524
524
  readonly jr: {
525
525
  readonly desc: {
526
- readonly en: "Jumps to code line (current line number + a)";
527
- readonly zh: "跳转到代码行号(当前行号+a)行";
526
+ readonly "en-us": "Jumps to code line (current line number + a)";
527
+ readonly "zh-hans": "跳转到代码行号(当前行号+a)行";
528
528
  };
529
529
  };
530
530
  readonly l: {
531
531
  readonly desc: {
532
- readonly en: "Loads the logic property value (LogicType) of the device corresponding to logic pin (d?) into register (r?)";
533
- readonly zh: "将逻辑引脚(d?)对应设备的逻辑属性值(LogicType)加载到寄存器(r?)中";
532
+ readonly "en-us": "Loads the logic property value (LogicType) of the device corresponding to logic pin (d?) into register (r?)";
533
+ readonly "zh-hans": "将逻辑引脚(d?)对应设备的逻辑属性值(LogicType)加载到寄存器(r?)中";
534
534
  };
535
535
  };
536
536
  readonly lb: {
537
537
  readonly desc: {
538
- readonly en: "Loads logic property values (LogicType) of all devices of the same type in the network into the register using the specified aggregation method, based on the given device type hash. Available modes: Average(0), Sum(1), Minimum(2), Maximum(3); supports both word and number";
539
- readonly zh: "通过给定的设备类型哈希值(deviceHash)，将网络内所有同类设备的逻辑属性值(LogicType)以指定统计方式加载到寄存器。可用统计方式：Average(0)平均、Sum(1)求和、Minimum(2)最小、Maximum(3)最大，支持单词或数字";
538
+ readonly "en-us": "Loads logic property values (LogicType) of all devices of the same type in the network into the register using the specified aggregation method, based on the given device type hash. Available modes: Average(0), Sum(1), Minimum(2), Maximum(3); supports both word and number";
539
+ readonly "zh-hans": "通过给定的设备类型哈希值(deviceHash)，将网络内所有同类设备的逻辑属性值(LogicType)以指定统计方式加载到寄存器。可用统计方式：Average(0)平均、Sum(1)求和、Minimum(2)最小、Maximum(3)最大，支持单词或数字";
540
540
  };
541
541
  };
542
542
  readonly lbn: {
543
543
  readonly desc: {
544
- readonly en: "Loads logic property values of all matching devices in the network into the register using the specified aggregation method, based on the given device type hash and device name hash. Available modes: Average(0), Sum(1), Minimum(2), Maximum(3); supports both word and number";
545
- readonly zh: "通过给定的设备类型哈希值与设备名称哈希值，将网络内所有符合条件设备的逻辑属性值以指定统计方式加载到寄存器。可用统计方式：Average(0)平均、Sum(1)求和、Minimum(2)最小、Maximum(3)最大，支持单词或数字";
544
+ readonly "en-us": "Loads logic property values of all matching devices in the network into the register using the specified aggregation method, based on the given device type hash and device name hash. Available modes: Average(0), Sum(1), Minimum(2), Maximum(3); supports both word and number";
545
+ readonly "zh-hans": "通过给定的设备类型哈希值与设备名称哈希值，将网络内所有符合条件设备的逻辑属性值以指定统计方式加载到寄存器。可用统计方式：Average(0)平均、Sum(1)求和、Minimum(2)最小、Maximum(3)最大，支持单词或数字";
546
546
  };
547
547
  };
548
548
  readonly lbns: {
549
549
  readonly desc: {
550
- readonly en: "Loads logic property values of specific slots from all matching devices in the network into the register using the specified aggregation method, based on device type hash, slot index and device name hash. Available modes: Average(0), Sum(1), Minimum(2), Maximum(3); supports both word and number";
551
- readonly zh: "通过给定的设备类型哈希值、槽位索引值、设备名称哈希值，将网络内所有符合条件设备的特定槽位逻辑属性值以指定统计方式加载到寄存器。可用统计方式：Average(0)平均、Sum(1)求和、Minimum(2)最小、Maximum(3)最大，支持单词或数字";
550
+ readonly "en-us": "Loads logic property values of specific slots from all matching devices in the network into the register using the specified aggregation method, based on device type hash, slot index and device name hash. Available modes: Average(0), Sum(1), Minimum(2), Maximum(3); supports both word and number";
551
+ readonly "zh-hans": "通过给定的设备类型哈希值、槽位索引值、设备名称哈希值，将网络内所有符合条件设备的特定槽位逻辑属性值以指定统计方式加载到寄存器。可用统计方式：Average(0)平均、Sum(1)求和、Minimum(2)最小、Maximum(3)最大，支持单词或数字";
552
552
  };
553
553
  };
554
554
  readonly lbs: {
555
555
  readonly desc: {
556
- readonly en: "Loads logic property values of specific slots from all matching devices in the network into the register using the specified aggregation method, based on device type hash and slot index. Available modes: Average(0), Sum(1), Minimum(2), Maximum(3); supports both word and number";
557
- readonly zh: "通过给定的设备类型哈希值与槽位索引值，将网络内所有符合条件设备中特定槽位的逻辑属性值以指定统计方式加载到寄存器。可用统计方式：Average(0)平均、Sum(1)求和、Minimum(2)最小、Maximum(3)最大，支持单词或数字";
556
+ readonly "en-us": "Loads logic property values of specific slots from all matching devices in the network into the register using the specified aggregation method, based on device type hash and slot index. Available modes: Average(0), Sum(1), Minimum(2), Maximum(3); supports both word and number";
557
+ readonly "zh-hans": "通过给定的设备类型哈希值与槽位索引值，将网络内所有符合条件设备中特定槽位的逻辑属性值以指定统计方式加载到寄存器。可用统计方式：Average(0)平均、Sum(1)求和、Minimum(2)最小、Maximum(3)最大，支持单词或数字";
558
558
  };
559
559
  };
560
560
  readonly lerp: {
561
561
  readonly desc: {
562
- readonly en: "Performs linear interpolation between a and b with ratio c, and places the result into the provided register. The ratio c will be clamped between 0 and 1";
563
- readonly zh: "以比率c在a和b之间进行线性插值，并将结果放入指定寄存器。比率c会被限制在0到1之间";
562
+ readonly "en-us": "Performs linear interpolation between a and b with ratio c, and places the result into the provided register. The ratio c will be clamped between 0 and 1";
563
+ readonly "zh-hans": "以比率c在a和b之间进行线性插值，并将结果放入指定寄存器。比率c会被限制在0到1之间";
564
564
  };
565
565
  };
566
566
  readonly log: {
567
567
  readonly desc: {
568
- readonly en: "Calculates the natural logarithm log(a) of a, and stores it in register (r?)";
569
- readonly zh: "计算a以自然常数为底的对数log(a)，并保存在寄存器(r?)中";
568
+ readonly "en-us": "Calculates the natural logarithm log(a) of a, and stores it in register (r?)";
569
+ readonly "zh-hans": "计算a以自然常数为底的对数log(a)，并保存在寄存器(r?)中";
570
570
  };
571
571
  };
572
572
  readonly lr: {
573
573
  readonly desc: {
574
- readonly en: "Loads the reagent hash value from the device corresponding to logic pin (d?) into the register using the specified reagent mode. Available modes: Contents(0), Required(1), Recipe(2); supports both word and number";
575
- readonly zh: "对逻辑引脚(d?)对应的设备，通过指定的原料模式(ReagentMode)将原料的哈希值加载到寄存器。可用模式：Contents(0)内含、Required(1)需求、Recipe(2)配方，支持单词或数字";
574
+ readonly "en-us": "Loads the reagent hash value from the device corresponding to logic pin (d?) into the register using the specified reagent mode. Available modes: Contents(0), Required(1), Recipe(2); supports both word and number";
575
+ readonly "zh-hans": "对逻辑引脚(d?)对应的设备，通过指定的原料模式(ReagentMode)将原料的哈希值加载到寄存器。可用模式：Contents(0)内含、Required(1)需求、Recipe(2)配方，支持单词或数字";
576
576
  };
577
577
  };
578
578
  readonly ls: {
579
579
  readonly desc: {
580
- readonly en: "Loads the logic slot property value (LogicSlotType) of the item in the slot at the specified index of the device corresponding to logic pin (d?) into register (r?)";
581
- readonly zh: "将逻辑引脚(d?)对应设备的指定槽位索引中物品的逻辑槽位属性值(LogicSlotType)加载到寄存器(r?)中";
580
+ readonly "en-us": "Loads the logic slot property value (LogicSlotType) of the item in the slot at the specified index of the device corresponding to logic pin (d?) into register (r?)";
581
+ readonly "zh-hans": "将逻辑引脚(d?)对应设备的指定槽位索引中物品的逻辑槽位属性值(LogicSlotType)加载到寄存器(r?)中";
582
582
  };
583
583
  };
584
584
  readonly max: {
585
585
  readonly desc: {
586
- readonly en: "Compares a and b, and stores the larger value in register (r?)";
587
- readonly zh: "比较a和b，并将较大值保存在寄存器(r?)中";
586
+ readonly "en-us": "Compares a and b, and stores the larger value in register (r?)";
587
+ readonly "zh-hans": "比较a和b，并将较大值保存在寄存器(r?)中";
588
588
  };
589
589
  };
590
590
  readonly min: {
591
591
  readonly desc: {
592
- readonly en: "Compares a and b, and stores the smaller value in register (r?)";
593
- readonly zh: "比较a和b，并将较小值保存在寄存器(r?)中";
592
+ readonly "en-us": "Compares a and b, and stores the smaller value in register (r?)";
593
+ readonly "zh-hans": "比较a和b，并将较小值保存在寄存器(r?)中";
594
594
  };
595
595
  };
596
596
  readonly mod: {
597
597
  readonly desc: {
598
- readonly en: "Calculates the result of a modulo b and stores it in register (r?). Note: this is not equivalent to the a % b remainder operator";
599
- readonly zh: "计算a模以b的结果并保存在寄存器(r?)中，注意：并非取余运算符a%b";
598
+ readonly "en-us": "Calculates the result of a modulo b and stores it in register (r?). Note: this is not equivalent to the a % b remainder operator";
599
+ readonly "zh-hans": "计算a模以b的结果并保存在寄存器(r?)中，注意：并非取余运算符a%b";
600
600
  };
601
601
  };
602
602
  readonly move: {
603
603
  readonly desc: {
604
- readonly en: "Assigns the specified value (register or constant) to register (r?)";
605
- readonly zh: "将指定的值（寄存器或常量）赋值给寄存器(r?)";
604
+ readonly "en-us": "Assigns the specified value (register or constant) to register (r?)";
605
+ readonly "zh-hans": "将指定的值（寄存器或常量）赋值给寄存器(r?)";
606
606
  };
607
607
  };
608
608
  readonly mul: {
609
609
  readonly desc: {
610
- readonly en: "Calculates the result of a * b and stores it in register (r?)";
611
- readonly zh: "计算a*b的结果并保存在寄存器(r?)中";
610
+ readonly "en-us": "Calculates the result of a * b and stores it in register (r?)";
611
+ readonly "zh-hans": "计算a*b的结果并保存在寄存器(r?)中";
612
612
  };
613
613
  };
614
614
  readonly nan: {
615
615
  readonly desc: {
616
- readonly en: "A constant representing 'not a number'. This constant technically provides a 'quiet' NaN, a signal NaN from some instructions will result in an exception and halt execution";
617
- readonly zh: "表示“非数值”的常量。该常量在技术上是一个“安静型”NaN，部分指令产生的信号型NaN会触发异常并终止执行。";
616
+ readonly "en-us": "A constant representing 'not a number'. This constant technically provides a 'quiet' NaN, a signal NaN from some instructions will result in an exception and halt execution";
617
+ readonly "zh-hans": "表示“非数值”的常量。该常量在技术上是一个“安静型”NaN，部分指令产生的信号型NaN会触发异常并终止执行。";
618
618
  };
619
619
  };
620
620
  readonly ninf: {
621
621
  readonly desc: {
622
- readonly en: "A constant representing a negative infinite value";
623
- readonly zh: "表示负无穷大值的常量";
622
+ readonly "en-us": "A constant representing a negative infinite value";
623
+ readonly "zh-hans": "表示负无穷大值的常量";
624
624
  };
625
625
  };
626
626
  readonly nor: {
627
627
  readonly desc: {
628
- readonly en: "Performs a bitwise NOR operation on the binary representations of two values. Each result bit is determined by the corresponding input bits: 1 if both bits are 0, 0 if either bit is 1";
629
- readonly zh: "对两个数值的二进制表示执行按位NOR(或非)运算。结果每一位由输入对应位决定：两位都为0时结果位为1，任意一位为1则结果位为0";
628
+ readonly "en-us": "Performs a bitwise NOR operation on the binary representations of two values. Each result bit is determined by the corresponding input bits: 1 if both bits are 0, 0 if either bit is 1";
629
+ readonly "zh-hans": "对两个数值的二进制表示执行按位NOR(或非)运算。结果每一位由输入对应位决定：两位都为0时结果位为1，任意一位为1则结果位为0";
630
630
  };
631
631
  };
632
632
  readonly not: {
633
633
  readonly desc: {
634
- readonly en: "Performs a bitwise NOT operation on the binary representation of a value, inverting every bit: 1 becomes 0 and 0 becomes 1";
635
- readonly zh: "对数值的二进制表示执行按位NOT(非)运算，将所有二进制位取反，1变0、0变1";
634
+ readonly "en-us": "Performs a bitwise NOT operation on the binary representation of a value, inverting every bit: 1 becomes 0 and 0 becomes 1";
635
+ readonly "zh-hans": "对数值的二进制表示执行按位NOT(非)运算，将所有二进制位取反，1变0、0变1";
636
636
  };
637
637
  };
638
638
  readonly or: {
639
639
  readonly desc: {
640
- readonly en: "Performs a bitwise OR operation on the binary representations of two values. Each result bit is 1 if either input bit is 1, and 0 only if both bits are 0";
641
- readonly zh: "对两个数值的二进制表示执行按位OR(或)运算。结果每一位由输入对应位决定：任意一位为1则结果位为1，都为0时结果位为0";
640
+ readonly "en-us": "Performs a bitwise OR operation on the binary representations of two values. Each result bit is 1 if either input bit is 1, and 0 only if both bits are 0";
641
+ readonly "zh-hans": "对两个数值的二进制表示执行按位OR(或)运算。结果每一位由输入对应位决定：任意一位为1则结果位为1，都为0时结果位为0";
642
642
  };
643
643
  };
644
644
  readonly peek: {
645
645
  readonly desc: {
646
- readonly en: "Gets the value at the top of the stack and stores it in register (r?)";
647
- readonly zh: "获取堆栈顶的值，并保存在寄存器(r?)中";
646
+ readonly "en-us": "Gets the value at the top of the stack and stores it in register (r?)";
647
+ readonly "zh-hans": "获取堆栈顶的值，并保存在寄存器(r?)中";
648
648
  };
649
649
  };
650
650
  readonly pi: {
651
651
  readonly desc: {
652
- readonly en: "A constant representing ratio of the circumference of a circle to its diameter, provided in double precision. Value: 3.14159265358979";
653
- readonly zh: "表示圆的周长与直径比值的常量，以双精度浮点数提供，取值为 3.14159265358979";
652
+ readonly "en-us": "A constant representing ratio of the circumference of a circle to its diameter, provided in double precision. Value: 3.14159265358979";
653
+ readonly "zh-hans": "表示圆的周长与直径比值的常量，以双精度浮点数提供，取值为 3.14159265358979";
654
654
  };
655
655
  };
656
656
  readonly pinf: {
657
657
  readonly desc: {
658
- readonly en: "A constant representing a positive infinite value";
659
- readonly zh: "表示正无穷大值的常量";
658
+ readonly "en-us": "A constant representing a positive infinite value";
659
+ readonly "zh-hans": "表示正无穷大值的常量";
660
660
  };
661
661
  };
662
662
  readonly poke: {
663
663
  readonly desc: {
664
- readonly en: "Stores the specified value at the given index in the stack";
665
- readonly zh: "将指定值存储到堆栈的指定索引位置";
664
+ readonly "en-us": "Stores the specified value at the given index in the stack";
665
+ readonly "zh-hans": "将指定值存储到堆栈的指定索引位置";
666
666
  };
667
667
  };
668
668
  readonly pop: {
669
669
  readonly desc: {
670
- readonly en: "Stores the value at the top of the stack in register (r?), and increments the stack pointer register sp by 1";
671
- readonly zh: "将堆栈顶的值保存在寄存器(r?)中，并将堆栈指针寄存器sp的值+1";
670
+ readonly "en-us": "Stores the value at the top of the stack in register (r?), and increments the stack pointer register sp by 1";
671
+ readonly "zh-hans": "将堆栈顶的值保存在寄存器(r?)中，并将堆栈指针寄存器sp的值+1";
672
672
  };
673
673
  };
674
674
  readonly pow: {
675
675
  readonly desc: {
676
- readonly en: "Calculates a raised to the power of b and stores the result in the register. Follows the IEEE-754 floating-point arithmetic standard";
677
- readonly zh: "计算a的b次幂并将结果存入寄存器，遵循IEEE-754浮点算术标准";
676
+ readonly "en-us": "Calculates a raised to the power of b and stores the result in the register. Follows the IEEE-754 floating-point arithmetic standard";
677
+ readonly "zh-hans": "计算a的b次幂并将结果存入寄存器，遵循IEEE-754浮点算术标准";
678
678
  };
679
679
  };
680
680
  readonly push: {
681
681
  readonly desc: {
682
- readonly en: "Pushes value a onto the stack, and increments the stack pointer register sp by 1";
683
- readonly zh: "将a值压入堆栈，并将堆栈指针寄存器sp的值+1";
682
+ readonly "en-us": "Pushes value a onto the stack, and increments the stack pointer register sp by 1";
683
+ readonly "zh-hans": "将a值压入堆栈，并将堆栈指针寄存器sp的值+1";
684
684
  };
685
685
  };
686
686
  readonly put: {
687
687
  readonly desc: {
688
- readonly en: "Attempts to write the specified value to the specified address in the stack of the target device";
689
- readonly zh: "尝试将指定的值写入指定设备堆栈的指定地址";
688
+ readonly "en-us": "Attempts to write the specified value to the specified address in the stack of the target device";
689
+ readonly "zh-hans": "尝试将指定的值写入指定设备堆栈的指定地址";
690
690
  };
691
691
  };
692
692
  readonly rad2deg: {
693
693
  readonly desc: {
694
- readonly en: "Radians to degrees conversion constant. Value: 57.2957801818848";
695
- readonly zh: "弧度转角度的换算常量，取值为 57.2957801818848";
694
+ readonly "en-us": "Radians to degrees conversion constant. Value: 57.2957801818848";
695
+ readonly "zh-hans": "弧度转角度的换算常量，取值为 57.2957801818848";
696
696
  };
697
697
  };
698
698
  readonly rand: {
699
699
  readonly desc: {
700
- readonly en: "Generates a random number in the range 0 <= x < 1, and stores it in register (r?)";
701
- readonly zh: "生成范围为0<=x<1的随机数，并保存在寄存器(r?)中";
700
+ readonly "en-us": "Generates a random number in the range 0 <= x < 1, and stores it in register (r?)";
701
+ readonly "zh-hans": "生成范围为0<=x<1的随机数，并保存在寄存器(r?)中";
702
702
  };
703
703
  };
704
704
  readonly rgas: {
705
705
  readonly desc: {
706
- readonly en: "Universal gas constant (J/(mol*K)). Value: 8.31446261815324";
707
- readonly zh: "通用气体常数，单位为焦耳每摩尔开尔文（J/(mol*K)），取值为 8.31446261815324";
706
+ readonly "en-us": "Universal gas constant (J/(mol*K)). Value: 8.31446261815324";
707
+ readonly "zh-hans": "通用气体常数，单位为焦耳每摩尔开尔文（J/(mol*K)），取值为 8.31446261815324";
708
708
  };
709
709
  };
710
710
  readonly rmap: {
711
711
  readonly desc: {
712
- readonly en: "Returns the quantity of the corresponding material required by the device's recipe, based on the given material hash (e.g. querying iron hash for an automatic lathe returns iron ingot hash)";
713
- readonly zh: "根据给定的材料哈希值，返回设备配方所需的对应材料数量（例如查询自动车床中铁的哈希值，返回对应铁锭的哈希值）";
712
+ readonly "en-us": "Returns the quantity of the corresponding material required by the device's recipe, based on the given material hash (e.g. querying iron hash for an automatic lathe returns iron ingot hash)";
713
+ readonly "zh-hans": "根据给定的材料哈希值，返回设备配方所需的对应材料数量（例如查询自动车床中铁的哈希值，返回对应铁锭的哈希值）";
714
714
  };
715
715
  };
716
716
  readonly rol: {
717
717
  readonly desc: {
718
- readonly en: "Performs a bitwise left rotation on the binary representation of a by b places, wrapping bits shifted out of the most significant position back into the least significant position";
719
- readonly zh: "对a的二进制表示执行按位左循环移位b位，将从最高位移出的比特回绕到最低位";
718
+ readonly "en-us": "Performs a bitwise left rotation on the binary representation of a by b places, wrapping bits shifted out of the most significant position back into the least significant position";
719
+ readonly "zh-hans": "对a的二进制表示执行按位左循环移位b位，将从最高位移出的比特回绕到最低位";
720
720
  };
721
721
  };
722
722
  readonly ror: {
723
723
  readonly desc: {
724
- readonly en: "Performs a bitwise right rotation on the binary representation of a by b places, wrapping bits shifted out of the least significant position back into the most significant position";
725
- readonly zh: "对a的二进制表示执行按位右循环移位b位，将从最低位移出的比特回绕到最高位";
724
+ readonly "en-us": "Performs a bitwise right rotation on the binary representation of a by b places, wrapping bits shifted out of the least significant position back into the most significant position";
725
+ readonly "zh-hans": "对a的二进制表示执行按位右循环移位b位，将从最低位移出的比特回绕到最高位";
726
726
  };
727
727
  };
728
728
  readonly round: {
729
729
  readonly desc: {
730
- readonly en: "Calculates the integer result of a rounded to the nearest whole number, and stores it in register (r?)";
731
- readonly zh: "计算a四舍五入后的整数结果，并保存在寄存器(r?)中";
730
+ readonly "en-us": "Calculates the integer result of a rounded to the nearest whole number, and stores it in register (r?)";
731
+ readonly "zh-hans": "计算a四舍五入后的整数结果，并保存在寄存器(r?)中";
732
732
  };
733
733
  };
734
734
  readonly s: {
735
735
  readonly desc: {
736
- readonly en: "Writes the value of register (r?) to the logic property (LogicType) of the device corresponding to the specified logic pin (d?)";
737
- readonly zh: "将寄存器(r?)的值写入指定逻辑引脚(d?)所对应设备的逻辑属性值(LogicType)";
736
+ readonly "en-us": "Writes the value of register (r?) to the logic property (LogicType) of the device corresponding to the specified logic pin (d?)";
737
+ readonly "zh-hans": "将寄存器(r?)的值写入指定逻辑引脚(d?)所对应设备的逻辑属性值(LogicType)";
738
738
  };
739
739
  };
740
740
  readonly sap: {
741
741
  readonly desc: {
742
- readonly en: "Sets register (r?) to 1 if abs(a-b) <= max(c * max(abs(a), abs(b)), float.epsilon * 8), otherwise 0";
743
- readonly zh: "当符合abs(a-b)<=max(c*max(abs(a), abs(b)), float.epsilon*8)时，寄存器(r?)为1，否则为0";
742
+ readonly "en-us": "Sets register (r?) to 1 if abs(a-b) <= max(c * max(abs(a), abs(b)), float.epsilon * 8), otherwise 0";
743
+ readonly "zh-hans": "当符合abs(a-b)<=max(c*max(abs(a), abs(b)), float.epsilon*8)时，寄存器(r?)为1，否则为0";
744
744
  };
745
745
  };
746
746
  readonly sapz: {
747
747
  readonly desc: {
748
- readonly en: "Sets register (r?) to 1 if |a| <= float.epsilon * 8, otherwise 0";
749
- readonly zh: "当符合|a|<=float.epsilon*8时，寄存器(r?)为1，否则为0";
748
+ readonly "en-us": "Sets register (r?) to 1 if |a| <= float.epsilon * 8, otherwise 0";
749
+ readonly "zh-hans": "当符合|a|<=float.epsilon*8时，寄存器(r?)为1，否则为0";
750
750
  };
751
751
  };
752
752
  readonly sb: {
753
753
  readonly desc: {
754
- readonly en: "Writes the value of register (r?) to the logic property (LogicType) of all matching devices in the network, based on the given device type hash";
755
- readonly zh: "通过给定的设备类型哈希值(deviceHash)，将寄存器(r?)的值写入到网络内所有符合条件的设备的逻辑属性值(LogicType)";
754
+ readonly "en-us": "Writes the value of register (r?) to the logic property (LogicType) of all matching devices in the network, based on the given device type hash";
755
+ readonly "zh-hans": "通过给定的设备类型哈希值(deviceHash)，将寄存器(r?)的值写入到网络内所有符合条件的设备的逻辑属性值(LogicType)";
756
756
  };
757
757
  };
758
758
  readonly sbn: {
759
759
  readonly desc: {
760
- readonly en: "Writes the value of register (r?) to the logic property (LogicType) of all matching devices in the network, based on the given device type hash and device name hash";
761
- readonly zh: "通过给定的设备类型哈希值与设备名称哈希值，将寄存器(r?)的值写入到网络内所有符合条件的设备的逻辑属性值(LogicType)";
760
+ readonly "en-us": "Writes the value of register (r?) to the logic property (LogicType) of all matching devices in the network, based on the given device type hash and device name hash";
761
+ readonly "zh-hans": "通过给定的设备类型哈希值与设备名称哈希值，将寄存器(r?)的值写入到网络内所有符合条件的设备的逻辑属性值(LogicType)";
762
762
  };
763
763
  };
764
764
  readonly sbs: {
765
765
  readonly desc: {
766
- readonly en: "Writes the value of register (r?) to the logic slot property (LogicSlotType) of specific slots in all matching devices in the network, based on device type hash and slot index";
767
- readonly zh: "通过给定的设备类型哈希值与槽位索引值，将寄存器(r?)的值写入到网络内所有符合条件设备中特定槽位的逻辑槽位属性值(LogicSlotType)";
766
+ readonly "en-us": "Writes the value of register (r?) to the logic slot property (LogicSlotType) of specific slots in all matching devices in the network, based on device type hash and slot index";
767
+ readonly "zh-hans": "通过给定的设备类型哈希值与槽位索引值，将寄存器(r?)的值写入到网络内所有符合条件设备中特定槽位的逻辑槽位属性值(LogicSlotType)";
768
768
  };
769
769
  };
770
770
  readonly sdns: {
771
771
  readonly desc: {
772
- readonly en: "Sets register (r?) to 0 if the pin corresponding to device (d?) points to an invalid device, otherwise 1";
773
- readonly zh: "如果设备(d?)对应的引脚指向一个无效的设备，则寄存器(r?)的值为0，否则为1";
772
+ readonly "en-us": "Sets register (r?) to 0 if the pin corresponding to device (d?) points to an invalid device, otherwise 1";
773
+ readonly "zh-hans": "如果设备(d?)对应的引脚指向一个无效的设备，则寄存器(r?)的值为0，否则为1";
774
774
  };
775
775
  };
776
776
  readonly sdse: {
777
777
  readonly desc: {
778
- readonly en: "Sets register (r?) to 1 if the pin corresponding to device (d?) points to a valid device, otherwise 0";
779
- readonly zh: "如果设备(d?)对应的引脚指向一个有效的设备，则寄存器(r?)的值为1，否则为0";
778
+ readonly "en-us": "Sets register (r?) to 1 if the pin corresponding to device (d?) points to a valid device, otherwise 0";
779
+ readonly "zh-hans": "如果设备(d?)对应的引脚指向一个有效的设备，则寄存器(r?)的值为1，否则为0";
780
780
  };
781
781
  };
782
782
  readonly select: {
783
783
  readonly desc: {
784
- readonly en: "Sets register (r?) to b if a is not zero, otherwise c";
785
- readonly zh: "如果a不为0，则寄存器(r?)的值为b，否则为c";
784
+ readonly "en-us": "Sets register (r?) to b if a is not zero, otherwise c";
785
+ readonly "zh-hans": "如果a不为0，则寄存器(r?)的值为b，否则为c";
786
786
  };
787
787
  };
788
788
  readonly seq: {
789
789
  readonly desc: {
790
- readonly en: "Sets register (r?) to 1 if a == b, otherwise 0";
791
- readonly zh: "a==b时，寄存器(r?)为1，否则为0";
790
+ readonly "en-us": "Sets register (r?) to 1 if a == b, otherwise 0";
791
+ readonly "zh-hans": "a==b时，寄存器(r?)为1，否则为0";
792
792
  };
793
793
  };
794
794
  readonly seqz: {
795
795
  readonly desc: {
796
- readonly en: "Sets register (r?) to 1 if a == 0, otherwise 0";
797
- readonly zh: "a==0时，寄存器(r?)为1，否则为0";
796
+ readonly "en-us": "Sets register (r?) to 1 if a == 0, otherwise 0";
797
+ readonly "zh-hans": "a==0时，寄存器(r?)为1，否则为0";
798
798
  };
799
799
  };
800
800
  readonly sge: {
801
801
  readonly desc: {
802
- readonly en: "Sets register (r?) to 1 if a >= b, otherwise 0";
803
- readonly zh: "a>=b时，寄存器(r?)为1，否则为0";
802
+ readonly "en-us": "Sets register (r?) to 1 if a >= b, otherwise 0";
803
+ readonly "zh-hans": "a>=b时，寄存器(r?)为1，否则为0";
804
804
  };
805
805
  };
806
806
  readonly sgez: {
807
807
  readonly desc: {
808
- readonly en: "Sets register (r?) to 1 if a >= 0, otherwise 0";
809
- readonly zh: "a>=0时，寄存器(r?)为1，否则为0";
808
+ readonly "en-us": "Sets register (r?) to 1 if a >= 0, otherwise 0";
809
+ readonly "zh-hans": "a>=0时，寄存器(r?)为1，否则为0";
810
810
  };
811
811
  };
812
812
  readonly sgn: {
813
813
  readonly desc: {
814
- readonly en: "Stores the sign of a in the register: -1 if a is negative, 1 if positive, and 0 if a is zero or not a number";
815
- readonly zh: "将a的符号存入寄存器：负数为-1，正数为1，零或非数值为0";
814
+ readonly "en-us": "Stores the sign of a in the register: -1 if a is negative, 1 if positive, and 0 if a is zero or not a number";
815
+ readonly "zh-hans": "将a的符号存入寄存器：负数为-1，正数为1，零或非数值为0";
816
816
  };
817
817
  };
818
818
  readonly sgt: {
819
819
  readonly desc: {
820
- readonly en: "Sets register (r?) to 1 if a > b, otherwise 0";
821
- readonly zh: "a>b时，寄存器(r?)为1，否则为0";
820
+ readonly "en-us": "Sets register (r?) to 1 if a > b, otherwise 0";
821
+ readonly "zh-hans": "a>b时，寄存器(r?)为1，否则为0";
822
822
  };
823
823
  };
824
824
  readonly sgtz: {
825
825
  readonly desc: {
826
- readonly en: "Sets register (r?) to 1 if a > 0, otherwise 0";
827
- readonly zh: "a>0时，寄存器(r?)为1，否则为0";
826
+ readonly "en-us": "Sets register (r?) to 1 if a > 0, otherwise 0";
827
+ readonly "zh-hans": "a>0时，寄存器(r?)为1，否则为0";
828
828
  };
829
829
  };
830
830
  readonly sin: {
831
831
  readonly desc: {
832
- readonly en: "Calculates the sine value of the arc length a, and stores it in register (r?)";
833
- readonly zh: "计算弧长为a的正弦值，并保存在寄存器(r?)中";
832
+ readonly "en-us": "Calculates the sine value of the arc length a, and stores it in register (r?)";
833
+ readonly "zh-hans": "计算弧长为a的正弦值，并保存在寄存器(r?)中";
834
834
  };
835
835
  };
836
836
  readonly sla: {
837
837
  readonly desc: {
838
- readonly en: "Performs an arithmetic left shift on the binary representation of a value, shifting all bits left and filling the right side with the sign bit";
839
- readonly zh: "对数值的二进制表示执行算术左移位，将所有二进制位向左移动，并用符号位填充右侧空出的部分";
838
+ readonly "en-us": "Performs an arithmetic left shift on the binary representation of a value, shifting all bits left and filling the right side with the sign bit";
839
+ readonly "zh-hans": "对数值的二进制表示执行算术左移位，将所有二进制位向左移动，并用符号位填充右侧空出的部分";
840
840
  };
841
841
  };
842
842
  readonly sle: {
843
843
  readonly desc: {
844
- readonly en: "Sets register (r?) to 1 if a <= b, otherwise 0";
845
- readonly zh: "a<=b时，寄存器(r?)为1，否则为0";
844
+ readonly "en-us": "Sets register (r?) to 1 if a <= b, otherwise 0";
845
+ readonly "zh-hans": "a<=b时，寄存器(r?)为1，否则为0";
846
846
  };
847
847
  };
848
848
  readonly sleep: {
849
849
  readonly desc: {
850
- readonly en: "Pauses code execution for a seconds";
851
- readonly zh: "暂停代码运行a秒";
850
+ readonly "en-us": "Pauses code execution for a seconds";
851
+ readonly "zh-hans": "暂停代码运行a秒";
852
852
  };
853
853
  };
854
854
  readonly slez: {
855
855
  readonly desc: {
856
- readonly en: "Sets register (r?) to 1 if a <= 0, otherwise 0";
857
- readonly zh: "a<=0时，寄存器(r?)为1，否则为0";
856
+ readonly "en-us": "Sets register (r?) to 1 if a <= 0, otherwise 0";
857
+ readonly "zh-hans": "a<=0时，寄存器(r?)为1，否则为0";
858
858
  };
859
859
  };
860
860
  readonly sll: {
861
861
  readonly desc: {
862
- readonly en: "Performs a logical left shift on the binary representation of a value, shifting all bits left and filling the right side with 0";
863
- readonly zh: "对数值的二进制表示执行逻辑左移位，将所有二进制位向左移动，并用0填充右侧空出的部分";
862
+ readonly "en-us": "Performs a logical left shift on the binary representation of a value, shifting all bits left and filling the right side with 0";
863
+ readonly "zh-hans": "对数值的二进制表示执行逻辑左移位，将所有二进制位向左移动，并用0填充右侧空出的部分";
864
864
  };
865
865
  };
866
866
  readonly slt: {
867
867
  readonly desc: {
868
- readonly en: "Sets register (r?) to 1 if a < b, otherwise 0";
869
- readonly zh: "a<b时，寄存器(r?)为1，否则为0";
868
+ readonly "en-us": "Sets register (r?) to 1 if a < b, otherwise 0";
869
+ readonly "zh-hans": "a<b时，寄存器(r?)为1，否则为0";
870
870
  };
871
871
  };
872
872
  readonly sltz: {
873
873
  readonly desc: {
874
- readonly en: "Sets register (r?) to 1 if a < 0, otherwise 0";
875
- readonly zh: "a<0时，寄存器(r?)为1，否则为0";
874
+ readonly "en-us": "Sets register (r?) to 1 if a < 0, otherwise 0";
875
+ readonly "zh-hans": "a<0时，寄存器(r?)为1，否则为0";
876
876
  };
877
877
  };
878
878
  readonly sna: {
879
879
  readonly desc: {
880
- readonly en: "Sets register (r?) to 1 if abs(a-b) > max(c * max(abs(a), abs(b)), float.epsilon * 8), otherwise 0";
881
- readonly zh: "当符合abs(a-b)>max(c*max(abs(a), abs(b)), float.epsilon*8)时，寄存器(r?)为1，否则为0";
880
+ readonly "en-us": "Sets register (r?) to 1 if abs(a-b) > max(c * max(abs(a), abs(b)), float.epsilon * 8), otherwise 0";
881
+ readonly "zh-hans": "当符合abs(a-b)>max(c*max(abs(a), abs(b)), float.epsilon*8)时，寄存器(r?)为1，否则为0";
882
882
  };
883
883
  };
884
884
  readonly snan: {
885
885
  readonly desc: {
886
- readonly en: "Sets register (r?) to 1 if a == NaN, otherwise 0. NaN is a special constant used when a calculation result is meaningless, such as division by zero";
887
- readonly zh: "a==NaN时，寄存器(r?)为1，否则为0。NaN是特殊常量，当计算结果无意义（如除以0）时，存储结果的寄存器值为NaN";
886
+ readonly "en-us": "Sets register (r?) to 1 if a == NaN, otherwise 0. NaN is a special constant used when a calculation result is meaningless, such as division by zero";
887
+ readonly "zh-hans": "a==NaN时，寄存器(r?)为1，否则为0。NaN是特殊常量，当计算结果无意义（如除以0）时，存储结果的寄存器值为NaN";
888
888
  };
889
889
  };
890
890
  readonly snanz: {
891
891
  readonly desc: {
892
- readonly en: "Sets register (r?) to 0 if a == NaN, otherwise 1. NaN is a special value used when a calculation result is meaningless, such as division by zero";
893
- readonly zh: "a==NaN时，寄存器(r?)为0，否则为1。NaN是特殊值，当计算结果无意义（如除以0）时，存储结果的寄存器值为NaN";
892
+ readonly "en-us": "Sets register (r?) to 0 if a == NaN, otherwise 1. NaN is a special value used when a calculation result is meaningless, such as division by zero";
893
+ readonly "zh-hans": "a==NaN时，寄存器(r?)为0，否则为1。NaN是特殊值，当计算结果无意义（如除以0）时，存储结果的寄存器值为NaN";
894
894
  };
895
895
  };
896
896
  readonly snaz: {
897
897
  readonly desc: {
898
- readonly en: "Sets register (r?) to 1 if |a| > float.epsilon, otherwise 0";
899
- readonly zh: "当符合|a|>float.epsilon时，寄存器(r?)为1，否则为0";
898
+ readonly "en-us": "Sets register (r?) to 1 if |a| > float.epsilon, otherwise 0";
899
+ readonly "zh-hans": "当符合|a|>float.epsilon时，寄存器(r?)为1，否则为0";
900
900
  };
901
901
  };
902
902
  readonly sne: {
903
903
  readonly desc: {
904
- readonly en: "Sets register (r?) to 1 if a != b, otherwise 0";
905
- readonly zh: "a!=b时，寄存器(r?)为1，否则为0";
904
+ readonly "en-us": "Sets register (r?) to 1 if a != b, otherwise 0";
905
+ readonly "zh-hans": "a!=b时，寄存器(r?)为1，否则为0";
906
906
  };
907
907
  };
908
908
  readonly snez: {
909
909
  readonly desc: {
910
- readonly en: "Sets register (r?) to 1 if a != 0, otherwise 0";
911
- readonly zh: "a!=0时，寄存器(r?)为1，否则为0";
910
+ readonly "en-us": "Sets register (r?) to 1 if a != 0, otherwise 0";
911
+ readonly "zh-hans": "a!=0时，寄存器(r?)为1，否则为0";
912
912
  };
913
913
  };
914
914
  readonly sqrt: {
915
915
  readonly desc: {
916
- readonly en: "Calculates the square root of a and stores the result in register (r?)";
917
- readonly zh: "计算a的平方根并将结果保存在寄存器(r?)中";
916
+ readonly "en-us": "Calculates the square root of a and stores the result in register (r?)";
917
+ readonly "zh-hans": "计算a的平方根并将结果保存在寄存器(r?)中";
918
918
  };
919
919
  };
920
920
  readonly sra: {
921
921
  readonly desc: {
922
- readonly en: "Performs an arithmetic right shift on the binary representation of a value, shifting all bits right and filling the left side with the sign bit";
923
- readonly zh: "对数值的二进制表示执行算术右移位，将所有二进制位向右移动，并用符号位填充左侧空出的部分";
922
+ readonly "en-us": "Performs an arithmetic right shift on the binary representation of a value, shifting all bits right and filling the left side with the sign bit";
923
+ readonly "zh-hans": "对数值的二进制表示执行算术右移位，将所有二进制位向右移动，并用符号位填充左侧空出的部分";
924
924
  };
925
925
  };
926
926
  readonly srl: {
927
927
  readonly desc: {
928
- readonly en: "Performs a logical right shift on the binary representation of a value, shifting all bits right and filling the left side with 0";
929
- readonly zh: "对数值的二进制表示执行逻辑右移位，将所有二进制位向右移动，并用0填充左侧空出的部分";
928
+ readonly "en-us": "Performs a logical right shift on the binary representation of a value, shifting all bits right and filling the left side with 0";
929
+ readonly "zh-hans": "对数值的二进制表示执行逻辑右移位，将所有二进制位向右移动，并用0填充左侧空出的部分";
930
930
  };
931
931
  };
932
932
  readonly ss: {
933
933
  readonly desc: {
934
- readonly en: "Locates the device in the device slot via logic pin (d?) and slot index, then writes the value of register (r?) to its logic slot property (LogicSlotType)";
935
- readonly zh: "通过逻辑引脚(d?)和槽位索引定位到设备槽位中的设备，将寄存器(r?)的值写入该设备的逻辑槽位属性值(LogicSlotType)";
934
+ readonly "en-us": "Locates the device in the device slot via logic pin (d?) and slot index, then writes the value of register (r?) to its logic slot property (LogicSlotType)";
935
+ readonly "zh-hans": "通过逻辑引脚(d?)和槽位索引定位到设备槽位中的设备，将寄存器(r?)的值写入该设备的逻辑槽位属性值(LogicSlotType)";
936
936
  };
937
937
  };
938
938
  readonly str: {
939
939
  readonly desc: {
940
- readonly en: "any text inside will be packed into 53 usable bits of the 64 bit backing number that can be used for drawing text. This limits its use to 6 characters.";
941
- readonly zh: "括号内的任意文本会被打包进64位底层数值的53个可用比特中，可用于绘制文本。该限制使其最多支持6个字符。";
940
+ readonly "en-us": "any text inside will be packed into 53 usable bits of the 64 bit backing number that can be used for drawing text. This limits its use to 6 characters.";
941
+ readonly "zh-hans": "括号内的任意文本会被打包进64位底层数值的53个可用比特中，可用于绘制文本。该限制使其最多支持6个字符。";
942
942
  };
943
943
  };
944
944
  readonly sub: {
945
945
  readonly desc: {
946
- readonly en: "Calculates the result of a - b and stores it in register (r?)";
947
- readonly zh: "计算a-b的结果并保存在寄存器(r?)中";
946
+ readonly "en-us": "Calculates the result of a - b and stores it in register (r?)";
947
+ readonly "zh-hans": "计算a-b的结果并保存在寄存器(r?)中";
948
948
  };
949
949
  };
950
950
  readonly tan: {
951
951
  readonly desc: {
952
- readonly en: "Calculates the tangent value of the arc length a, and stores it in register (r?)";
953
- readonly zh: "计算弧长为a的正切值，并保存在寄存器(r?)中";
952
+ readonly "en-us": "Calculates the tangent value of the arc length a, and stores it in register (r?)";
953
+ readonly "zh-hans": "计算弧长为a的正切值，并保存在寄存器(r?)中";
954
954
  };
955
955
  };
956
956
  readonly tau: {
957
957
  readonly desc: {
958
- readonly en: "A constant representing the ratio of the circumference of a circle to its radius, provided in double precision. Value: 6.28318530717959";
959
- readonly zh: "表示圆的周长与半径比值的常量，以双精度浮点数提供，取值为 6.28318530717959";
958
+ readonly "en-us": "A constant representing the ratio of the circumference of a circle to its radius, provided in double precision. Value: 6.28318530717959";
959
+ readonly "zh-hans": "表示圆的周长与半径比值的常量，以双精度浮点数提供，取值为 6.28318530717959";
960
960
  };
961
961
  };
962
962
  readonly trunc: {
963
963
  readonly desc: {
964
- readonly en: "Calculates the result of a with the fractional part truncated, and stores it in register (r?)";
965
- readonly zh: "计算a舍去小数部分后的结果，并保存在寄存器(r?)中";
964
+ readonly "en-us": "Calculates the result of a with the fractional part truncated, and stores it in register (r?)";
965
+ readonly "zh-hans": "计算a舍去小数部分后的结果，并保存在寄存器(r?)中";
966
966
  };
967
967
  };
968
968
  readonly xor: {
969
969
  readonly desc: {
970
- readonly en: "Performs a bitwise XOR operation on the binary representations of two values. Each result bit is 1 if the corresponding input bits differ, 0 if they are the same";
971
- readonly zh: "对两个数值的二进制表示执行按位XOR(异或)运算。两个对应位不同时结果位为1，相同时结果位为0";
970
+ readonly "en-us": "Performs a bitwise XOR operation on the binary representations of two values. Each result bit is 1 if the corresponding input bits differ, 0 if they are the same";
971
+ readonly "zh-hans": "对两个数值的二进制表示执行按位XOR(异或)运算。两个对应位不同时结果位为1，相同时结果位为0";
972
972
  };
973
973
  };
974
974
  readonly yield: {
975
975
  readonly desc: {
976
- readonly en: "Pauses code execution until the end of the current tick";
977
- readonly zh: "暂停代码运行直到当前tick结束";
976
+ readonly "en-us": "Pauses code execution until the end of the current tick";
977
+ readonly "zh-hans": "暂停代码运行直到当前tick结束";
978
978
  };
979
979
  };
980
980
  };