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