1// Code generated from gen/Wasm.rules; DO NOT EDIT.
2// generated with: cd gen; go run *.go
3
4package ssa
5
6import "cmd/internal/objabi"
7import "cmd/compile/internal/types"
8
9func rewriteValueWasm(v *Value) bool {
10	switch v.Op {
11	case OpAbs:
12		return rewriteValueWasm_OpAbs_0(v)
13	case OpAdd16:
14		return rewriteValueWasm_OpAdd16_0(v)
15	case OpAdd32:
16		return rewriteValueWasm_OpAdd32_0(v)
17	case OpAdd32F:
18		return rewriteValueWasm_OpAdd32F_0(v)
19	case OpAdd64:
20		return rewriteValueWasm_OpAdd64_0(v)
21	case OpAdd64F:
22		return rewriteValueWasm_OpAdd64F_0(v)
23	case OpAdd8:
24		return rewriteValueWasm_OpAdd8_0(v)
25	case OpAddPtr:
26		return rewriteValueWasm_OpAddPtr_0(v)
27	case OpAddr:
28		return rewriteValueWasm_OpAddr_0(v)
29	case OpAnd16:
30		return rewriteValueWasm_OpAnd16_0(v)
31	case OpAnd32:
32		return rewriteValueWasm_OpAnd32_0(v)
33	case OpAnd64:
34		return rewriteValueWasm_OpAnd64_0(v)
35	case OpAnd8:
36		return rewriteValueWasm_OpAnd8_0(v)
37	case OpAndB:
38		return rewriteValueWasm_OpAndB_0(v)
39	case OpBitLen64:
40		return rewriteValueWasm_OpBitLen64_0(v)
41	case OpCeil:
42		return rewriteValueWasm_OpCeil_0(v)
43	case OpClosureCall:
44		return rewriteValueWasm_OpClosureCall_0(v)
45	case OpCom16:
46		return rewriteValueWasm_OpCom16_0(v)
47	case OpCom32:
48		return rewriteValueWasm_OpCom32_0(v)
49	case OpCom64:
50		return rewriteValueWasm_OpCom64_0(v)
51	case OpCom8:
52		return rewriteValueWasm_OpCom8_0(v)
53	case OpCondSelect:
54		return rewriteValueWasm_OpCondSelect_0(v)
55	case OpConst16:
56		return rewriteValueWasm_OpConst16_0(v)
57	case OpConst32:
58		return rewriteValueWasm_OpConst32_0(v)
59	case OpConst32F:
60		return rewriteValueWasm_OpConst32F_0(v)
61	case OpConst64:
62		return rewriteValueWasm_OpConst64_0(v)
63	case OpConst64F:
64		return rewriteValueWasm_OpConst64F_0(v)
65	case OpConst8:
66		return rewriteValueWasm_OpConst8_0(v)
67	case OpConstBool:
68		return rewriteValueWasm_OpConstBool_0(v)
69	case OpConstNil:
70		return rewriteValueWasm_OpConstNil_0(v)
71	case OpConvert:
72		return rewriteValueWasm_OpConvert_0(v)
73	case OpCopysign:
74		return rewriteValueWasm_OpCopysign_0(v)
75	case OpCtz16:
76		return rewriteValueWasm_OpCtz16_0(v)
77	case OpCtz16NonZero:
78		return rewriteValueWasm_OpCtz16NonZero_0(v)
79	case OpCtz32:
80		return rewriteValueWasm_OpCtz32_0(v)
81	case OpCtz32NonZero:
82		return rewriteValueWasm_OpCtz32NonZero_0(v)
83	case OpCtz64:
84		return rewriteValueWasm_OpCtz64_0(v)
85	case OpCtz64NonZero:
86		return rewriteValueWasm_OpCtz64NonZero_0(v)
87	case OpCtz8:
88		return rewriteValueWasm_OpCtz8_0(v)
89	case OpCtz8NonZero:
90		return rewriteValueWasm_OpCtz8NonZero_0(v)
91	case OpCvt32Fto32:
92		return rewriteValueWasm_OpCvt32Fto32_0(v)
93	case OpCvt32Fto32U:
94		return rewriteValueWasm_OpCvt32Fto32U_0(v)
95	case OpCvt32Fto64:
96		return rewriteValueWasm_OpCvt32Fto64_0(v)
97	case OpCvt32Fto64F:
98		return rewriteValueWasm_OpCvt32Fto64F_0(v)
99	case OpCvt32Fto64U:
100		return rewriteValueWasm_OpCvt32Fto64U_0(v)
101	case OpCvt32Uto32F:
102		return rewriteValueWasm_OpCvt32Uto32F_0(v)
103	case OpCvt32Uto64F:
104		return rewriteValueWasm_OpCvt32Uto64F_0(v)
105	case OpCvt32to32F:
106		return rewriteValueWasm_OpCvt32to32F_0(v)
107	case OpCvt32to64F:
108		return rewriteValueWasm_OpCvt32to64F_0(v)
109	case OpCvt64Fto32:
110		return rewriteValueWasm_OpCvt64Fto32_0(v)
111	case OpCvt64Fto32F:
112		return rewriteValueWasm_OpCvt64Fto32F_0(v)
113	case OpCvt64Fto32U:
114		return rewriteValueWasm_OpCvt64Fto32U_0(v)
115	case OpCvt64Fto64:
116		return rewriteValueWasm_OpCvt64Fto64_0(v)
117	case OpCvt64Fto64U:
118		return rewriteValueWasm_OpCvt64Fto64U_0(v)
119	case OpCvt64Uto32F:
120		return rewriteValueWasm_OpCvt64Uto32F_0(v)
121	case OpCvt64Uto64F:
122		return rewriteValueWasm_OpCvt64Uto64F_0(v)
123	case OpCvt64to32F:
124		return rewriteValueWasm_OpCvt64to32F_0(v)
125	case OpCvt64to64F:
126		return rewriteValueWasm_OpCvt64to64F_0(v)
127	case OpDiv16:
128		return rewriteValueWasm_OpDiv16_0(v)
129	case OpDiv16u:
130		return rewriteValueWasm_OpDiv16u_0(v)
131	case OpDiv32:
132		return rewriteValueWasm_OpDiv32_0(v)
133	case OpDiv32F:
134		return rewriteValueWasm_OpDiv32F_0(v)
135	case OpDiv32u:
136		return rewriteValueWasm_OpDiv32u_0(v)
137	case OpDiv64:
138		return rewriteValueWasm_OpDiv64_0(v)
139	case OpDiv64F:
140		return rewriteValueWasm_OpDiv64F_0(v)
141	case OpDiv64u:
142		return rewriteValueWasm_OpDiv64u_0(v)
143	case OpDiv8:
144		return rewriteValueWasm_OpDiv8_0(v)
145	case OpDiv8u:
146		return rewriteValueWasm_OpDiv8u_0(v)
147	case OpEq16:
148		return rewriteValueWasm_OpEq16_0(v)
149	case OpEq32:
150		return rewriteValueWasm_OpEq32_0(v)
151	case OpEq32F:
152		return rewriteValueWasm_OpEq32F_0(v)
153	case OpEq64:
154		return rewriteValueWasm_OpEq64_0(v)
155	case OpEq64F:
156		return rewriteValueWasm_OpEq64F_0(v)
157	case OpEq8:
158		return rewriteValueWasm_OpEq8_0(v)
159	case OpEqB:
160		return rewriteValueWasm_OpEqB_0(v)
161	case OpEqPtr:
162		return rewriteValueWasm_OpEqPtr_0(v)
163	case OpFloor:
164		return rewriteValueWasm_OpFloor_0(v)
165	case OpGeq16:
166		return rewriteValueWasm_OpGeq16_0(v)
167	case OpGeq16U:
168		return rewriteValueWasm_OpGeq16U_0(v)
169	case OpGeq32:
170		return rewriteValueWasm_OpGeq32_0(v)
171	case OpGeq32F:
172		return rewriteValueWasm_OpGeq32F_0(v)
173	case OpGeq32U:
174		return rewriteValueWasm_OpGeq32U_0(v)
175	case OpGeq64:
176		return rewriteValueWasm_OpGeq64_0(v)
177	case OpGeq64F:
178		return rewriteValueWasm_OpGeq64F_0(v)
179	case OpGeq64U:
180		return rewriteValueWasm_OpGeq64U_0(v)
181	case OpGeq8:
182		return rewriteValueWasm_OpGeq8_0(v)
183	case OpGeq8U:
184		return rewriteValueWasm_OpGeq8U_0(v)
185	case OpGetCallerPC:
186		return rewriteValueWasm_OpGetCallerPC_0(v)
187	case OpGetCallerSP:
188		return rewriteValueWasm_OpGetCallerSP_0(v)
189	case OpGetClosurePtr:
190		return rewriteValueWasm_OpGetClosurePtr_0(v)
191	case OpGreater16:
192		return rewriteValueWasm_OpGreater16_0(v)
193	case OpGreater16U:
194		return rewriteValueWasm_OpGreater16U_0(v)
195	case OpGreater32:
196		return rewriteValueWasm_OpGreater32_0(v)
197	case OpGreater32F:
198		return rewriteValueWasm_OpGreater32F_0(v)
199	case OpGreater32U:
200		return rewriteValueWasm_OpGreater32U_0(v)
201	case OpGreater64:
202		return rewriteValueWasm_OpGreater64_0(v)
203	case OpGreater64F:
204		return rewriteValueWasm_OpGreater64F_0(v)
205	case OpGreater64U:
206		return rewriteValueWasm_OpGreater64U_0(v)
207	case OpGreater8:
208		return rewriteValueWasm_OpGreater8_0(v)
209	case OpGreater8U:
210		return rewriteValueWasm_OpGreater8U_0(v)
211	case OpInterCall:
212		return rewriteValueWasm_OpInterCall_0(v)
213	case OpIsInBounds:
214		return rewriteValueWasm_OpIsInBounds_0(v)
215	case OpIsNonNil:
216		return rewriteValueWasm_OpIsNonNil_0(v)
217	case OpIsSliceInBounds:
218		return rewriteValueWasm_OpIsSliceInBounds_0(v)
219	case OpLeq16:
220		return rewriteValueWasm_OpLeq16_0(v)
221	case OpLeq16U:
222		return rewriteValueWasm_OpLeq16U_0(v)
223	case OpLeq32:
224		return rewriteValueWasm_OpLeq32_0(v)
225	case OpLeq32F:
226		return rewriteValueWasm_OpLeq32F_0(v)
227	case OpLeq32U:
228		return rewriteValueWasm_OpLeq32U_0(v)
229	case OpLeq64:
230		return rewriteValueWasm_OpLeq64_0(v)
231	case OpLeq64F:
232		return rewriteValueWasm_OpLeq64F_0(v)
233	case OpLeq64U:
234		return rewriteValueWasm_OpLeq64U_0(v)
235	case OpLeq8:
236		return rewriteValueWasm_OpLeq8_0(v)
237	case OpLeq8U:
238		return rewriteValueWasm_OpLeq8U_0(v)
239	case OpLess16:
240		return rewriteValueWasm_OpLess16_0(v)
241	case OpLess16U:
242		return rewriteValueWasm_OpLess16U_0(v)
243	case OpLess32:
244		return rewriteValueWasm_OpLess32_0(v)
245	case OpLess32F:
246		return rewriteValueWasm_OpLess32F_0(v)
247	case OpLess32U:
248		return rewriteValueWasm_OpLess32U_0(v)
249	case OpLess64:
250		return rewriteValueWasm_OpLess64_0(v)
251	case OpLess64F:
252		return rewriteValueWasm_OpLess64F_0(v)
253	case OpLess64U:
254		return rewriteValueWasm_OpLess64U_0(v)
255	case OpLess8:
256		return rewriteValueWasm_OpLess8_0(v)
257	case OpLess8U:
258		return rewriteValueWasm_OpLess8U_0(v)
259	case OpLoad:
260		return rewriteValueWasm_OpLoad_0(v)
261	case OpLocalAddr:
262		return rewriteValueWasm_OpLocalAddr_0(v)
263	case OpLsh16x16:
264		return rewriteValueWasm_OpLsh16x16_0(v)
265	case OpLsh16x32:
266		return rewriteValueWasm_OpLsh16x32_0(v)
267	case OpLsh16x64:
268		return rewriteValueWasm_OpLsh16x64_0(v)
269	case OpLsh16x8:
270		return rewriteValueWasm_OpLsh16x8_0(v)
271	case OpLsh32x16:
272		return rewriteValueWasm_OpLsh32x16_0(v)
273	case OpLsh32x32:
274		return rewriteValueWasm_OpLsh32x32_0(v)
275	case OpLsh32x64:
276		return rewriteValueWasm_OpLsh32x64_0(v)
277	case OpLsh32x8:
278		return rewriteValueWasm_OpLsh32x8_0(v)
279	case OpLsh64x16:
280		return rewriteValueWasm_OpLsh64x16_0(v)
281	case OpLsh64x32:
282		return rewriteValueWasm_OpLsh64x32_0(v)
283	case OpLsh64x64:
284		return rewriteValueWasm_OpLsh64x64_0(v)
285	case OpLsh64x8:
286		return rewriteValueWasm_OpLsh64x8_0(v)
287	case OpLsh8x16:
288		return rewriteValueWasm_OpLsh8x16_0(v)
289	case OpLsh8x32:
290		return rewriteValueWasm_OpLsh8x32_0(v)
291	case OpLsh8x64:
292		return rewriteValueWasm_OpLsh8x64_0(v)
293	case OpLsh8x8:
294		return rewriteValueWasm_OpLsh8x8_0(v)
295	case OpMod16:
296		return rewriteValueWasm_OpMod16_0(v)
297	case OpMod16u:
298		return rewriteValueWasm_OpMod16u_0(v)
299	case OpMod32:
300		return rewriteValueWasm_OpMod32_0(v)
301	case OpMod32u:
302		return rewriteValueWasm_OpMod32u_0(v)
303	case OpMod64:
304		return rewriteValueWasm_OpMod64_0(v)
305	case OpMod64u:
306		return rewriteValueWasm_OpMod64u_0(v)
307	case OpMod8:
308		return rewriteValueWasm_OpMod8_0(v)
309	case OpMod8u:
310		return rewriteValueWasm_OpMod8u_0(v)
311	case OpMove:
312		return rewriteValueWasm_OpMove_0(v) || rewriteValueWasm_OpMove_10(v)
313	case OpMul16:
314		return rewriteValueWasm_OpMul16_0(v)
315	case OpMul32:
316		return rewriteValueWasm_OpMul32_0(v)
317	case OpMul32F:
318		return rewriteValueWasm_OpMul32F_0(v)
319	case OpMul64:
320		return rewriteValueWasm_OpMul64_0(v)
321	case OpMul64F:
322		return rewriteValueWasm_OpMul64F_0(v)
323	case OpMul8:
324		return rewriteValueWasm_OpMul8_0(v)
325	case OpNeg16:
326		return rewriteValueWasm_OpNeg16_0(v)
327	case OpNeg32:
328		return rewriteValueWasm_OpNeg32_0(v)
329	case OpNeg32F:
330		return rewriteValueWasm_OpNeg32F_0(v)
331	case OpNeg64:
332		return rewriteValueWasm_OpNeg64_0(v)
333	case OpNeg64F:
334		return rewriteValueWasm_OpNeg64F_0(v)
335	case OpNeg8:
336		return rewriteValueWasm_OpNeg8_0(v)
337	case OpNeq16:
338		return rewriteValueWasm_OpNeq16_0(v)
339	case OpNeq32:
340		return rewriteValueWasm_OpNeq32_0(v)
341	case OpNeq32F:
342		return rewriteValueWasm_OpNeq32F_0(v)
343	case OpNeq64:
344		return rewriteValueWasm_OpNeq64_0(v)
345	case OpNeq64F:
346		return rewriteValueWasm_OpNeq64F_0(v)
347	case OpNeq8:
348		return rewriteValueWasm_OpNeq8_0(v)
349	case OpNeqB:
350		return rewriteValueWasm_OpNeqB_0(v)
351	case OpNeqPtr:
352		return rewriteValueWasm_OpNeqPtr_0(v)
353	case OpNilCheck:
354		return rewriteValueWasm_OpNilCheck_0(v)
355	case OpNot:
356		return rewriteValueWasm_OpNot_0(v)
357	case OpOffPtr:
358		return rewriteValueWasm_OpOffPtr_0(v)
359	case OpOr16:
360		return rewriteValueWasm_OpOr16_0(v)
361	case OpOr32:
362		return rewriteValueWasm_OpOr32_0(v)
363	case OpOr64:
364		return rewriteValueWasm_OpOr64_0(v)
365	case OpOr8:
366		return rewriteValueWasm_OpOr8_0(v)
367	case OpOrB:
368		return rewriteValueWasm_OpOrB_0(v)
369	case OpPopCount16:
370		return rewriteValueWasm_OpPopCount16_0(v)
371	case OpPopCount32:
372		return rewriteValueWasm_OpPopCount32_0(v)
373	case OpPopCount64:
374		return rewriteValueWasm_OpPopCount64_0(v)
375	case OpPopCount8:
376		return rewriteValueWasm_OpPopCount8_0(v)
377	case OpRotateLeft16:
378		return rewriteValueWasm_OpRotateLeft16_0(v)
379	case OpRotateLeft32:
380		return rewriteValueWasm_OpRotateLeft32_0(v)
381	case OpRotateLeft64:
382		return rewriteValueWasm_OpRotateLeft64_0(v)
383	case OpRotateLeft8:
384		return rewriteValueWasm_OpRotateLeft8_0(v)
385	case OpRound32F:
386		return rewriteValueWasm_OpRound32F_0(v)
387	case OpRound64F:
388		return rewriteValueWasm_OpRound64F_0(v)
389	case OpRoundToEven:
390		return rewriteValueWasm_OpRoundToEven_0(v)
391	case OpRsh16Ux16:
392		return rewriteValueWasm_OpRsh16Ux16_0(v)
393	case OpRsh16Ux32:
394		return rewriteValueWasm_OpRsh16Ux32_0(v)
395	case OpRsh16Ux64:
396		return rewriteValueWasm_OpRsh16Ux64_0(v)
397	case OpRsh16Ux8:
398		return rewriteValueWasm_OpRsh16Ux8_0(v)
399	case OpRsh16x16:
400		return rewriteValueWasm_OpRsh16x16_0(v)
401	case OpRsh16x32:
402		return rewriteValueWasm_OpRsh16x32_0(v)
403	case OpRsh16x64:
404		return rewriteValueWasm_OpRsh16x64_0(v)
405	case OpRsh16x8:
406		return rewriteValueWasm_OpRsh16x8_0(v)
407	case OpRsh32Ux16:
408		return rewriteValueWasm_OpRsh32Ux16_0(v)
409	case OpRsh32Ux32:
410		return rewriteValueWasm_OpRsh32Ux32_0(v)
411	case OpRsh32Ux64:
412		return rewriteValueWasm_OpRsh32Ux64_0(v)
413	case OpRsh32Ux8:
414		return rewriteValueWasm_OpRsh32Ux8_0(v)
415	case OpRsh32x16:
416		return rewriteValueWasm_OpRsh32x16_0(v)
417	case OpRsh32x32:
418		return rewriteValueWasm_OpRsh32x32_0(v)
419	case OpRsh32x64:
420		return rewriteValueWasm_OpRsh32x64_0(v)
421	case OpRsh32x8:
422		return rewriteValueWasm_OpRsh32x8_0(v)
423	case OpRsh64Ux16:
424		return rewriteValueWasm_OpRsh64Ux16_0(v)
425	case OpRsh64Ux32:
426		return rewriteValueWasm_OpRsh64Ux32_0(v)
427	case OpRsh64Ux64:
428		return rewriteValueWasm_OpRsh64Ux64_0(v)
429	case OpRsh64Ux8:
430		return rewriteValueWasm_OpRsh64Ux8_0(v)
431	case OpRsh64x16:
432		return rewriteValueWasm_OpRsh64x16_0(v)
433	case OpRsh64x32:
434		return rewriteValueWasm_OpRsh64x32_0(v)
435	case OpRsh64x64:
436		return rewriteValueWasm_OpRsh64x64_0(v)
437	case OpRsh64x8:
438		return rewriteValueWasm_OpRsh64x8_0(v)
439	case OpRsh8Ux16:
440		return rewriteValueWasm_OpRsh8Ux16_0(v)
441	case OpRsh8Ux32:
442		return rewriteValueWasm_OpRsh8Ux32_0(v)
443	case OpRsh8Ux64:
444		return rewriteValueWasm_OpRsh8Ux64_0(v)
445	case OpRsh8Ux8:
446		return rewriteValueWasm_OpRsh8Ux8_0(v)
447	case OpRsh8x16:
448		return rewriteValueWasm_OpRsh8x16_0(v)
449	case OpRsh8x32:
450		return rewriteValueWasm_OpRsh8x32_0(v)
451	case OpRsh8x64:
452		return rewriteValueWasm_OpRsh8x64_0(v)
453	case OpRsh8x8:
454		return rewriteValueWasm_OpRsh8x8_0(v)
455	case OpSignExt16to32:
456		return rewriteValueWasm_OpSignExt16to32_0(v)
457	case OpSignExt16to64:
458		return rewriteValueWasm_OpSignExt16to64_0(v)
459	case OpSignExt32to64:
460		return rewriteValueWasm_OpSignExt32to64_0(v)
461	case OpSignExt8to16:
462		return rewriteValueWasm_OpSignExt8to16_0(v)
463	case OpSignExt8to32:
464		return rewriteValueWasm_OpSignExt8to32_0(v)
465	case OpSignExt8to64:
466		return rewriteValueWasm_OpSignExt8to64_0(v)
467	case OpSlicemask:
468		return rewriteValueWasm_OpSlicemask_0(v)
469	case OpSqrt:
470		return rewriteValueWasm_OpSqrt_0(v)
471	case OpStaticCall:
472		return rewriteValueWasm_OpStaticCall_0(v)
473	case OpStore:
474		return rewriteValueWasm_OpStore_0(v)
475	case OpSub16:
476		return rewriteValueWasm_OpSub16_0(v)
477	case OpSub32:
478		return rewriteValueWasm_OpSub32_0(v)
479	case OpSub32F:
480		return rewriteValueWasm_OpSub32F_0(v)
481	case OpSub64:
482		return rewriteValueWasm_OpSub64_0(v)
483	case OpSub64F:
484		return rewriteValueWasm_OpSub64F_0(v)
485	case OpSub8:
486		return rewriteValueWasm_OpSub8_0(v)
487	case OpSubPtr:
488		return rewriteValueWasm_OpSubPtr_0(v)
489	case OpTrunc:
490		return rewriteValueWasm_OpTrunc_0(v)
491	case OpTrunc16to8:
492		return rewriteValueWasm_OpTrunc16to8_0(v)
493	case OpTrunc32to16:
494		return rewriteValueWasm_OpTrunc32to16_0(v)
495	case OpTrunc32to8:
496		return rewriteValueWasm_OpTrunc32to8_0(v)
497	case OpTrunc64to16:
498		return rewriteValueWasm_OpTrunc64to16_0(v)
499	case OpTrunc64to32:
500		return rewriteValueWasm_OpTrunc64to32_0(v)
501	case OpTrunc64to8:
502		return rewriteValueWasm_OpTrunc64to8_0(v)
503	case OpWB:
504		return rewriteValueWasm_OpWB_0(v)
505	case OpWasmF64Add:
506		return rewriteValueWasm_OpWasmF64Add_0(v)
507	case OpWasmF64Mul:
508		return rewriteValueWasm_OpWasmF64Mul_0(v)
509	case OpWasmI64Add:
510		return rewriteValueWasm_OpWasmI64Add_0(v)
511	case OpWasmI64AddConst:
512		return rewriteValueWasm_OpWasmI64AddConst_0(v)
513	case OpWasmI64And:
514		return rewriteValueWasm_OpWasmI64And_0(v)
515	case OpWasmI64Eq:
516		return rewriteValueWasm_OpWasmI64Eq_0(v)
517	case OpWasmI64Eqz:
518		return rewriteValueWasm_OpWasmI64Eqz_0(v)
519	case OpWasmI64Load:
520		return rewriteValueWasm_OpWasmI64Load_0(v)
521	case OpWasmI64Load16S:
522		return rewriteValueWasm_OpWasmI64Load16S_0(v)
523	case OpWasmI64Load16U:
524		return rewriteValueWasm_OpWasmI64Load16U_0(v)
525	case OpWasmI64Load32S:
526		return rewriteValueWasm_OpWasmI64Load32S_0(v)
527	case OpWasmI64Load32U:
528		return rewriteValueWasm_OpWasmI64Load32U_0(v)
529	case OpWasmI64Load8S:
530		return rewriteValueWasm_OpWasmI64Load8S_0(v)
531	case OpWasmI64Load8U:
532		return rewriteValueWasm_OpWasmI64Load8U_0(v)
533	case OpWasmI64Mul:
534		return rewriteValueWasm_OpWasmI64Mul_0(v)
535	case OpWasmI64Ne:
536		return rewriteValueWasm_OpWasmI64Ne_0(v)
537	case OpWasmI64Or:
538		return rewriteValueWasm_OpWasmI64Or_0(v)
539	case OpWasmI64Shl:
540		return rewriteValueWasm_OpWasmI64Shl_0(v)
541	case OpWasmI64ShrS:
542		return rewriteValueWasm_OpWasmI64ShrS_0(v)
543	case OpWasmI64ShrU:
544		return rewriteValueWasm_OpWasmI64ShrU_0(v)
545	case OpWasmI64Store:
546		return rewriteValueWasm_OpWasmI64Store_0(v)
547	case OpWasmI64Store16:
548		return rewriteValueWasm_OpWasmI64Store16_0(v)
549	case OpWasmI64Store32:
550		return rewriteValueWasm_OpWasmI64Store32_0(v)
551	case OpWasmI64Store8:
552		return rewriteValueWasm_OpWasmI64Store8_0(v)
553	case OpWasmI64Xor:
554		return rewriteValueWasm_OpWasmI64Xor_0(v)
555	case OpXor16:
556		return rewriteValueWasm_OpXor16_0(v)
557	case OpXor32:
558		return rewriteValueWasm_OpXor32_0(v)
559	case OpXor64:
560		return rewriteValueWasm_OpXor64_0(v)
561	case OpXor8:
562		return rewriteValueWasm_OpXor8_0(v)
563	case OpZero:
564		return rewriteValueWasm_OpZero_0(v) || rewriteValueWasm_OpZero_10(v)
565	case OpZeroExt16to32:
566		return rewriteValueWasm_OpZeroExt16to32_0(v)
567	case OpZeroExt16to64:
568		return rewriteValueWasm_OpZeroExt16to64_0(v)
569	case OpZeroExt32to64:
570		return rewriteValueWasm_OpZeroExt32to64_0(v)
571	case OpZeroExt8to16:
572		return rewriteValueWasm_OpZeroExt8to16_0(v)
573	case OpZeroExt8to32:
574		return rewriteValueWasm_OpZeroExt8to32_0(v)
575	case OpZeroExt8to64:
576		return rewriteValueWasm_OpZeroExt8to64_0(v)
577	}
578	return false
579}
580func rewriteValueWasm_OpAbs_0(v *Value) bool {
581	// match: (Abs x)
582	// result: (F64Abs x)
583	for {
584		x := v.Args[0]
585		v.reset(OpWasmF64Abs)
586		v.AddArg(x)
587		return true
588	}
589}
590func rewriteValueWasm_OpAdd16_0(v *Value) bool {
591	// match: (Add16 x y)
592	// result: (I64Add x y)
593	for {
594		y := v.Args[1]
595		x := v.Args[0]
596		v.reset(OpWasmI64Add)
597		v.AddArg(x)
598		v.AddArg(y)
599		return true
600	}
601}
602func rewriteValueWasm_OpAdd32_0(v *Value) bool {
603	// match: (Add32 x y)
604	// result: (I64Add x y)
605	for {
606		y := v.Args[1]
607		x := v.Args[0]
608		v.reset(OpWasmI64Add)
609		v.AddArg(x)
610		v.AddArg(y)
611		return true
612	}
613}
614func rewriteValueWasm_OpAdd32F_0(v *Value) bool {
615	// match: (Add32F x y)
616	// result: (F32Add x y)
617	for {
618		y := v.Args[1]
619		x := v.Args[0]
620		v.reset(OpWasmF32Add)
621		v.AddArg(x)
622		v.AddArg(y)
623		return true
624	}
625}
626func rewriteValueWasm_OpAdd64_0(v *Value) bool {
627	// match: (Add64 x y)
628	// result: (I64Add x y)
629	for {
630		y := v.Args[1]
631		x := v.Args[0]
632		v.reset(OpWasmI64Add)
633		v.AddArg(x)
634		v.AddArg(y)
635		return true
636	}
637}
638func rewriteValueWasm_OpAdd64F_0(v *Value) bool {
639	// match: (Add64F x y)
640	// result: (F64Add x y)
641	for {
642		y := v.Args[1]
643		x := v.Args[0]
644		v.reset(OpWasmF64Add)
645		v.AddArg(x)
646		v.AddArg(y)
647		return true
648	}
649}
650func rewriteValueWasm_OpAdd8_0(v *Value) bool {
651	// match: (Add8 x y)
652	// result: (I64Add x y)
653	for {
654		y := v.Args[1]
655		x := v.Args[0]
656		v.reset(OpWasmI64Add)
657		v.AddArg(x)
658		v.AddArg(y)
659		return true
660	}
661}
662func rewriteValueWasm_OpAddPtr_0(v *Value) bool {
663	// match: (AddPtr x y)
664	// result: (I64Add x y)
665	for {
666		y := v.Args[1]
667		x := v.Args[0]
668		v.reset(OpWasmI64Add)
669		v.AddArg(x)
670		v.AddArg(y)
671		return true
672	}
673}
674func rewriteValueWasm_OpAddr_0(v *Value) bool {
675	// match: (Addr {sym} base)
676	// result: (LoweredAddr {sym} base)
677	for {
678		sym := v.Aux
679		base := v.Args[0]
680		v.reset(OpWasmLoweredAddr)
681		v.Aux = sym
682		v.AddArg(base)
683		return true
684	}
685}
686func rewriteValueWasm_OpAnd16_0(v *Value) bool {
687	// match: (And16 x y)
688	// result: (I64And x y)
689	for {
690		y := v.Args[1]
691		x := v.Args[0]
692		v.reset(OpWasmI64And)
693		v.AddArg(x)
694		v.AddArg(y)
695		return true
696	}
697}
698func rewriteValueWasm_OpAnd32_0(v *Value) bool {
699	// match: (And32 x y)
700	// result: (I64And x y)
701	for {
702		y := v.Args[1]
703		x := v.Args[0]
704		v.reset(OpWasmI64And)
705		v.AddArg(x)
706		v.AddArg(y)
707		return true
708	}
709}
710func rewriteValueWasm_OpAnd64_0(v *Value) bool {
711	// match: (And64 x y)
712	// result: (I64And x y)
713	for {
714		y := v.Args[1]
715		x := v.Args[0]
716		v.reset(OpWasmI64And)
717		v.AddArg(x)
718		v.AddArg(y)
719		return true
720	}
721}
722func rewriteValueWasm_OpAnd8_0(v *Value) bool {
723	// match: (And8 x y)
724	// result: (I64And x y)
725	for {
726		y := v.Args[1]
727		x := v.Args[0]
728		v.reset(OpWasmI64And)
729		v.AddArg(x)
730		v.AddArg(y)
731		return true
732	}
733}
734func rewriteValueWasm_OpAndB_0(v *Value) bool {
735	// match: (AndB x y)
736	// result: (I64And x y)
737	for {
738		y := v.Args[1]
739		x := v.Args[0]
740		v.reset(OpWasmI64And)
741		v.AddArg(x)
742		v.AddArg(y)
743		return true
744	}
745}
746func rewriteValueWasm_OpBitLen64_0(v *Value) bool {
747	b := v.Block
748	typ := &b.Func.Config.Types
749	// match: (BitLen64 x)
750	// result: (I64Sub (I64Const [64]) (I64Clz x))
751	for {
752		x := v.Args[0]
753		v.reset(OpWasmI64Sub)
754		v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
755		v0.AuxInt = 64
756		v.AddArg(v0)
757		v1 := b.NewValue0(v.Pos, OpWasmI64Clz, typ.Int64)
758		v1.AddArg(x)
759		v.AddArg(v1)
760		return true
761	}
762}
763func rewriteValueWasm_OpCeil_0(v *Value) bool {
764	// match: (Ceil x)
765	// result: (F64Ceil x)
766	for {
767		x := v.Args[0]
768		v.reset(OpWasmF64Ceil)
769		v.AddArg(x)
770		return true
771	}
772}
773func rewriteValueWasm_OpClosureCall_0(v *Value) bool {
774	// match: (ClosureCall [argwid] entry closure mem)
775	// result: (LoweredClosureCall [argwid] entry closure mem)
776	for {
777		argwid := v.AuxInt
778		mem := v.Args[2]
779		entry := v.Args[0]
780		closure := v.Args[1]
781		v.reset(OpWasmLoweredClosureCall)
782		v.AuxInt = argwid
783		v.AddArg(entry)
784		v.AddArg(closure)
785		v.AddArg(mem)
786		return true
787	}
788}
789func rewriteValueWasm_OpCom16_0(v *Value) bool {
790	b := v.Block
791	typ := &b.Func.Config.Types
792	// match: (Com16 x)
793	// result: (I64Xor x (I64Const [-1]))
794	for {
795		x := v.Args[0]
796		v.reset(OpWasmI64Xor)
797		v.AddArg(x)
798		v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
799		v0.AuxInt = -1
800		v.AddArg(v0)
801		return true
802	}
803}
804func rewriteValueWasm_OpCom32_0(v *Value) bool {
805	b := v.Block
806	typ := &b.Func.Config.Types
807	// match: (Com32 x)
808	// result: (I64Xor x (I64Const [-1]))
809	for {
810		x := v.Args[0]
811		v.reset(OpWasmI64Xor)
812		v.AddArg(x)
813		v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
814		v0.AuxInt = -1
815		v.AddArg(v0)
816		return true
817	}
818}
819func rewriteValueWasm_OpCom64_0(v *Value) bool {
820	b := v.Block
821	typ := &b.Func.Config.Types
822	// match: (Com64 x)
823	// result: (I64Xor x (I64Const [-1]))
824	for {
825		x := v.Args[0]
826		v.reset(OpWasmI64Xor)
827		v.AddArg(x)
828		v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
829		v0.AuxInt = -1
830		v.AddArg(v0)
831		return true
832	}
833}
834func rewriteValueWasm_OpCom8_0(v *Value) bool {
835	b := v.Block
836	typ := &b.Func.Config.Types
837	// match: (Com8 x)
838	// result: (I64Xor x (I64Const [-1]))
839	for {
840		x := v.Args[0]
841		v.reset(OpWasmI64Xor)
842		v.AddArg(x)
843		v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
844		v0.AuxInt = -1
845		v.AddArg(v0)
846		return true
847	}
848}
849func rewriteValueWasm_OpCondSelect_0(v *Value) bool {
850	// match: (CondSelect <t> x y cond)
851	// result: (Select <t> x y cond)
852	for {
853		t := v.Type
854		cond := v.Args[2]
855		x := v.Args[0]
856		y := v.Args[1]
857		v.reset(OpWasmSelect)
858		v.Type = t
859		v.AddArg(x)
860		v.AddArg(y)
861		v.AddArg(cond)
862		return true
863	}
864}
865func rewriteValueWasm_OpConst16_0(v *Value) bool {
866	// match: (Const16 [val])
867	// result: (I64Const [val])
868	for {
869		val := v.AuxInt
870		v.reset(OpWasmI64Const)
871		v.AuxInt = val
872		return true
873	}
874}
875func rewriteValueWasm_OpConst32_0(v *Value) bool {
876	// match: (Const32 [val])
877	// result: (I64Const [val])
878	for {
879		val := v.AuxInt
880		v.reset(OpWasmI64Const)
881		v.AuxInt = val
882		return true
883	}
884}
885func rewriteValueWasm_OpConst32F_0(v *Value) bool {
886	// match: (Const32F [val])
887	// result: (F32Const [val])
888	for {
889		val := v.AuxInt
890		v.reset(OpWasmF32Const)
891		v.AuxInt = val
892		return true
893	}
894}
895func rewriteValueWasm_OpConst64_0(v *Value) bool {
896	// match: (Const64 [val])
897	// result: (I64Const [val])
898	for {
899		val := v.AuxInt
900		v.reset(OpWasmI64Const)
901		v.AuxInt = val
902		return true
903	}
904}
905func rewriteValueWasm_OpConst64F_0(v *Value) bool {
906	// match: (Const64F [val])
907	// result: (F64Const [val])
908	for {
909		val := v.AuxInt
910		v.reset(OpWasmF64Const)
911		v.AuxInt = val
912		return true
913	}
914}
915func rewriteValueWasm_OpConst8_0(v *Value) bool {
916	// match: (Const8 [val])
917	// result: (I64Const [val])
918	for {
919		val := v.AuxInt
920		v.reset(OpWasmI64Const)
921		v.AuxInt = val
922		return true
923	}
924}
925func rewriteValueWasm_OpConstBool_0(v *Value) bool {
926	// match: (ConstBool [b])
927	// result: (I64Const [b])
928	for {
929		b := v.AuxInt
930		v.reset(OpWasmI64Const)
931		v.AuxInt = b
932		return true
933	}
934}
935func rewriteValueWasm_OpConstNil_0(v *Value) bool {
936	// match: (ConstNil)
937	// result: (I64Const [0])
938	for {
939		v.reset(OpWasmI64Const)
940		v.AuxInt = 0
941		return true
942	}
943}
944func rewriteValueWasm_OpConvert_0(v *Value) bool {
945	// match: (Convert <t> x mem)
946	// result: (LoweredConvert <t> x mem)
947	for {
948		t := v.Type
949		mem := v.Args[1]
950		x := v.Args[0]
951		v.reset(OpWasmLoweredConvert)
952		v.Type = t
953		v.AddArg(x)
954		v.AddArg(mem)
955		return true
956	}
957}
958func rewriteValueWasm_OpCopysign_0(v *Value) bool {
959	// match: (Copysign x y)
960	// result: (F64Copysign x y)
961	for {
962		y := v.Args[1]
963		x := v.Args[0]
964		v.reset(OpWasmF64Copysign)
965		v.AddArg(x)
966		v.AddArg(y)
967		return true
968	}
969}
970func rewriteValueWasm_OpCtz16_0(v *Value) bool {
971	b := v.Block
972	typ := &b.Func.Config.Types
973	// match: (Ctz16 x)
974	// result: (I64Ctz (I64Or x (I64Const [0x10000])))
975	for {
976		x := v.Args[0]
977		v.reset(OpWasmI64Ctz)
978		v0 := b.NewValue0(v.Pos, OpWasmI64Or, typ.Int64)
979		v0.AddArg(x)
980		v1 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
981		v1.AuxInt = 0x10000
982		v0.AddArg(v1)
983		v.AddArg(v0)
984		return true
985	}
986}
987func rewriteValueWasm_OpCtz16NonZero_0(v *Value) bool {
988	// match: (Ctz16NonZero x)
989	// result: (I64Ctz x)
990	for {
991		x := v.Args[0]
992		v.reset(OpWasmI64Ctz)
993		v.AddArg(x)
994		return true
995	}
996}
997func rewriteValueWasm_OpCtz32_0(v *Value) bool {
998	b := v.Block
999	typ := &b.Func.Config.Types
1000	// match: (Ctz32 x)
1001	// result: (I64Ctz (I64Or x (I64Const [0x100000000])))
1002	for {
1003		x := v.Args[0]
1004		v.reset(OpWasmI64Ctz)
1005		v0 := b.NewValue0(v.Pos, OpWasmI64Or, typ.Int64)
1006		v0.AddArg(x)
1007		v1 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
1008		v1.AuxInt = 0x100000000
1009		v0.AddArg(v1)
1010		v.AddArg(v0)
1011		return true
1012	}
1013}
1014func rewriteValueWasm_OpCtz32NonZero_0(v *Value) bool {
1015	// match: (Ctz32NonZero x)
1016	// result: (I64Ctz x)
1017	for {
1018		x := v.Args[0]
1019		v.reset(OpWasmI64Ctz)
1020		v.AddArg(x)
1021		return true
1022	}
1023}
1024func rewriteValueWasm_OpCtz64_0(v *Value) bool {
1025	// match: (Ctz64 x)
1026	// result: (I64Ctz x)
1027	for {
1028		x := v.Args[0]
1029		v.reset(OpWasmI64Ctz)
1030		v.AddArg(x)
1031		return true
1032	}
1033}
1034func rewriteValueWasm_OpCtz64NonZero_0(v *Value) bool {
1035	// match: (Ctz64NonZero x)
1036	// result: (I64Ctz x)
1037	for {
1038		x := v.Args[0]
1039		v.reset(OpWasmI64Ctz)
1040		v.AddArg(x)
1041		return true
1042	}
1043}
1044func rewriteValueWasm_OpCtz8_0(v *Value) bool {
1045	b := v.Block
1046	typ := &b.Func.Config.Types
1047	// match: (Ctz8 x)
1048	// result: (I64Ctz (I64Or x (I64Const [0x100])))
1049	for {
1050		x := v.Args[0]
1051		v.reset(OpWasmI64Ctz)
1052		v0 := b.NewValue0(v.Pos, OpWasmI64Or, typ.Int64)
1053		v0.AddArg(x)
1054		v1 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
1055		v1.AuxInt = 0x100
1056		v0.AddArg(v1)
1057		v.AddArg(v0)
1058		return true
1059	}
1060}
1061func rewriteValueWasm_OpCtz8NonZero_0(v *Value) bool {
1062	// match: (Ctz8NonZero x)
1063	// result: (I64Ctz x)
1064	for {
1065		x := v.Args[0]
1066		v.reset(OpWasmI64Ctz)
1067		v.AddArg(x)
1068		return true
1069	}
1070}
1071func rewriteValueWasm_OpCvt32Fto32_0(v *Value) bool {
1072	// match: (Cvt32Fto32 x)
1073	// result: (I64TruncSatF32S x)
1074	for {
1075		x := v.Args[0]
1076		v.reset(OpWasmI64TruncSatF32S)
1077		v.AddArg(x)
1078		return true
1079	}
1080}
1081func rewriteValueWasm_OpCvt32Fto32U_0(v *Value) bool {
1082	// match: (Cvt32Fto32U x)
1083	// result: (I64TruncSatF32U x)
1084	for {
1085		x := v.Args[0]
1086		v.reset(OpWasmI64TruncSatF32U)
1087		v.AddArg(x)
1088		return true
1089	}
1090}
1091func rewriteValueWasm_OpCvt32Fto64_0(v *Value) bool {
1092	// match: (Cvt32Fto64 x)
1093	// result: (I64TruncSatF32S x)
1094	for {
1095		x := v.Args[0]
1096		v.reset(OpWasmI64TruncSatF32S)
1097		v.AddArg(x)
1098		return true
1099	}
1100}
1101func rewriteValueWasm_OpCvt32Fto64F_0(v *Value) bool {
1102	// match: (Cvt32Fto64F x)
1103	// result: (F64PromoteF32 x)
1104	for {
1105		x := v.Args[0]
1106		v.reset(OpWasmF64PromoteF32)
1107		v.AddArg(x)
1108		return true
1109	}
1110}
1111func rewriteValueWasm_OpCvt32Fto64U_0(v *Value) bool {
1112	// match: (Cvt32Fto64U x)
1113	// result: (I64TruncSatF32U x)
1114	for {
1115		x := v.Args[0]
1116		v.reset(OpWasmI64TruncSatF32U)
1117		v.AddArg(x)
1118		return true
1119	}
1120}
1121func rewriteValueWasm_OpCvt32Uto32F_0(v *Value) bool {
1122	b := v.Block
1123	typ := &b.Func.Config.Types
1124	// match: (Cvt32Uto32F x)
1125	// result: (F32ConvertI64U (ZeroExt32to64 x))
1126	for {
1127		x := v.Args[0]
1128		v.reset(OpWasmF32ConvertI64U)
1129		v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
1130		v0.AddArg(x)
1131		v.AddArg(v0)
1132		return true
1133	}
1134}
1135func rewriteValueWasm_OpCvt32Uto64F_0(v *Value) bool {
1136	b := v.Block
1137	typ := &b.Func.Config.Types
1138	// match: (Cvt32Uto64F x)
1139	// result: (F64ConvertI64U (ZeroExt32to64 x))
1140	for {
1141		x := v.Args[0]
1142		v.reset(OpWasmF64ConvertI64U)
1143		v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
1144		v0.AddArg(x)
1145		v.AddArg(v0)
1146		return true
1147	}
1148}
1149func rewriteValueWasm_OpCvt32to32F_0(v *Value) bool {
1150	b := v.Block
1151	typ := &b.Func.Config.Types
1152	// match: (Cvt32to32F x)
1153	// result: (F32ConvertI64S (SignExt32to64 x))
1154	for {
1155		x := v.Args[0]
1156		v.reset(OpWasmF32ConvertI64S)
1157		v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
1158		v0.AddArg(x)
1159		v.AddArg(v0)
1160		return true
1161	}
1162}
1163func rewriteValueWasm_OpCvt32to64F_0(v *Value) bool {
1164	b := v.Block
1165	typ := &b.Func.Config.Types
1166	// match: (Cvt32to64F x)
1167	// result: (F64ConvertI64S (SignExt32to64 x))
1168	for {
1169		x := v.Args[0]
1170		v.reset(OpWasmF64ConvertI64S)
1171		v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
1172		v0.AddArg(x)
1173		v.AddArg(v0)
1174		return true
1175	}
1176}
1177func rewriteValueWasm_OpCvt64Fto32_0(v *Value) bool {
1178	// match: (Cvt64Fto32 x)
1179	// result: (I64TruncSatF64S x)
1180	for {
1181		x := v.Args[0]
1182		v.reset(OpWasmI64TruncSatF64S)
1183		v.AddArg(x)
1184		return true
1185	}
1186}
1187func rewriteValueWasm_OpCvt64Fto32F_0(v *Value) bool {
1188	// match: (Cvt64Fto32F x)
1189	// result: (F32DemoteF64 x)
1190	for {
1191		x := v.Args[0]
1192		v.reset(OpWasmF32DemoteF64)
1193		v.AddArg(x)
1194		return true
1195	}
1196}
1197func rewriteValueWasm_OpCvt64Fto32U_0(v *Value) bool {
1198	// match: (Cvt64Fto32U x)
1199	// result: (I64TruncSatF64U x)
1200	for {
1201		x := v.Args[0]
1202		v.reset(OpWasmI64TruncSatF64U)
1203		v.AddArg(x)
1204		return true
1205	}
1206}
1207func rewriteValueWasm_OpCvt64Fto64_0(v *Value) bool {
1208	// match: (Cvt64Fto64 x)
1209	// result: (I64TruncSatF64S x)
1210	for {
1211		x := v.Args[0]
1212		v.reset(OpWasmI64TruncSatF64S)
1213		v.AddArg(x)
1214		return true
1215	}
1216}
1217func rewriteValueWasm_OpCvt64Fto64U_0(v *Value) bool {
1218	// match: (Cvt64Fto64U x)
1219	// result: (I64TruncSatF64U x)
1220	for {
1221		x := v.Args[0]
1222		v.reset(OpWasmI64TruncSatF64U)
1223		v.AddArg(x)
1224		return true
1225	}
1226}
1227func rewriteValueWasm_OpCvt64Uto32F_0(v *Value) bool {
1228	// match: (Cvt64Uto32F x)
1229	// result: (F32ConvertI64U x)
1230	for {
1231		x := v.Args[0]
1232		v.reset(OpWasmF32ConvertI64U)
1233		v.AddArg(x)
1234		return true
1235	}
1236}
1237func rewriteValueWasm_OpCvt64Uto64F_0(v *Value) bool {
1238	// match: (Cvt64Uto64F x)
1239	// result: (F64ConvertI64U x)
1240	for {
1241		x := v.Args[0]
1242		v.reset(OpWasmF64ConvertI64U)
1243		v.AddArg(x)
1244		return true
1245	}
1246}
1247func rewriteValueWasm_OpCvt64to32F_0(v *Value) bool {
1248	// match: (Cvt64to32F x)
1249	// result: (F32ConvertI64S x)
1250	for {
1251		x := v.Args[0]
1252		v.reset(OpWasmF32ConvertI64S)
1253		v.AddArg(x)
1254		return true
1255	}
1256}
1257func rewriteValueWasm_OpCvt64to64F_0(v *Value) bool {
1258	// match: (Cvt64to64F x)
1259	// result: (F64ConvertI64S x)
1260	for {
1261		x := v.Args[0]
1262		v.reset(OpWasmF64ConvertI64S)
1263		v.AddArg(x)
1264		return true
1265	}
1266}
1267func rewriteValueWasm_OpDiv16_0(v *Value) bool {
1268	b := v.Block
1269	typ := &b.Func.Config.Types
1270	// match: (Div16 x y)
1271	// result: (I64DivS (SignExt16to64 x) (SignExt16to64 y))
1272	for {
1273		y := v.Args[1]
1274		x := v.Args[0]
1275		v.reset(OpWasmI64DivS)
1276		v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
1277		v0.AddArg(x)
1278		v.AddArg(v0)
1279		v1 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
1280		v1.AddArg(y)
1281		v.AddArg(v1)
1282		return true
1283	}
1284}
1285func rewriteValueWasm_OpDiv16u_0(v *Value) bool {
1286	b := v.Block
1287	typ := &b.Func.Config.Types
1288	// match: (Div16u x y)
1289	// result: (I64DivU (ZeroExt16to64 x) (ZeroExt16to64 y))
1290	for {
1291		y := v.Args[1]
1292		x := v.Args[0]
1293		v.reset(OpWasmI64DivU)
1294		v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
1295		v0.AddArg(x)
1296		v.AddArg(v0)
1297		v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
1298		v1.AddArg(y)
1299		v.AddArg(v1)
1300		return true
1301	}
1302}
1303func rewriteValueWasm_OpDiv32_0(v *Value) bool {
1304	b := v.Block
1305	typ := &b.Func.Config.Types
1306	// match: (Div32 x y)
1307	// result: (I64DivS (SignExt32to64 x) (SignExt32to64 y))
1308	for {
1309		y := v.Args[1]
1310		x := v.Args[0]
1311		v.reset(OpWasmI64DivS)
1312		v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
1313		v0.AddArg(x)
1314		v.AddArg(v0)
1315		v1 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
1316		v1.AddArg(y)
1317		v.AddArg(v1)
1318		return true
1319	}
1320}
1321func rewriteValueWasm_OpDiv32F_0(v *Value) bool {
1322	// match: (Div32F x y)
1323	// result: (F32Div x y)
1324	for {
1325		y := v.Args[1]
1326		x := v.Args[0]
1327		v.reset(OpWasmF32Div)
1328		v.AddArg(x)
1329		v.AddArg(y)
1330		return true
1331	}
1332}
1333func rewriteValueWasm_OpDiv32u_0(v *Value) bool {
1334	b := v.Block
1335	typ := &b.Func.Config.Types
1336	// match: (Div32u x y)
1337	// result: (I64DivU (ZeroExt32to64 x) (ZeroExt32to64 y))
1338	for {
1339		y := v.Args[1]
1340		x := v.Args[0]
1341		v.reset(OpWasmI64DivU)
1342		v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
1343		v0.AddArg(x)
1344		v.AddArg(v0)
1345		v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
1346		v1.AddArg(y)
1347		v.AddArg(v1)
1348		return true
1349	}
1350}
1351func rewriteValueWasm_OpDiv64_0(v *Value) bool {
1352	// match: (Div64 x y)
1353	// result: (I64DivS x y)
1354	for {
1355		y := v.Args[1]
1356		x := v.Args[0]
1357		v.reset(OpWasmI64DivS)
1358		v.AddArg(x)
1359		v.AddArg(y)
1360		return true
1361	}
1362}
1363func rewriteValueWasm_OpDiv64F_0(v *Value) bool {
1364	// match: (Div64F x y)
1365	// result: (F64Div x y)
1366	for {
1367		y := v.Args[1]
1368		x := v.Args[0]
1369		v.reset(OpWasmF64Div)
1370		v.AddArg(x)
1371		v.AddArg(y)
1372		return true
1373	}
1374}
1375func rewriteValueWasm_OpDiv64u_0(v *Value) bool {
1376	// match: (Div64u x y)
1377	// result: (I64DivU x y)
1378	for {
1379		y := v.Args[1]
1380		x := v.Args[0]
1381		v.reset(OpWasmI64DivU)
1382		v.AddArg(x)
1383		v.AddArg(y)
1384		return true
1385	}
1386}
1387func rewriteValueWasm_OpDiv8_0(v *Value) bool {
1388	b := v.Block
1389	typ := &b.Func.Config.Types
1390	// match: (Div8 x y)
1391	// result: (I64DivS (SignExt8to64 x) (SignExt8to64 y))
1392	for {
1393		y := v.Args[1]
1394		x := v.Args[0]
1395		v.reset(OpWasmI64DivS)
1396		v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
1397		v0.AddArg(x)
1398		v.AddArg(v0)
1399		v1 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
1400		v1.AddArg(y)
1401		v.AddArg(v1)
1402		return true
1403	}
1404}
1405func rewriteValueWasm_OpDiv8u_0(v *Value) bool {
1406	b := v.Block
1407	typ := &b.Func.Config.Types
1408	// match: (Div8u x y)
1409	// result: (I64DivU (ZeroExt8to64 x) (ZeroExt8to64 y))
1410	for {
1411		y := v.Args[1]
1412		x := v.Args[0]
1413		v.reset(OpWasmI64DivU)
1414		v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
1415		v0.AddArg(x)
1416		v.AddArg(v0)
1417		v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
1418		v1.AddArg(y)
1419		v.AddArg(v1)
1420		return true
1421	}
1422}
1423func rewriteValueWasm_OpEq16_0(v *Value) bool {
1424	b := v.Block
1425	typ := &b.Func.Config.Types
1426	// match: (Eq16 x y)
1427	// result: (I64Eq (ZeroExt16to64 x) (ZeroExt16to64 y))
1428	for {
1429		y := v.Args[1]
1430		x := v.Args[0]
1431		v.reset(OpWasmI64Eq)
1432		v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
1433		v0.AddArg(x)
1434		v.AddArg(v0)
1435		v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
1436		v1.AddArg(y)
1437		v.AddArg(v1)
1438		return true
1439	}
1440}
1441func rewriteValueWasm_OpEq32_0(v *Value) bool {
1442	b := v.Block
1443	typ := &b.Func.Config.Types
1444	// match: (Eq32 x y)
1445	// result: (I64Eq (ZeroExt32to64 x) (ZeroExt32to64 y))
1446	for {
1447		y := v.Args[1]
1448		x := v.Args[0]
1449		v.reset(OpWasmI64Eq)
1450		v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
1451		v0.AddArg(x)
1452		v.AddArg(v0)
1453		v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
1454		v1.AddArg(y)
1455		v.AddArg(v1)
1456		return true
1457	}
1458}
1459func rewriteValueWasm_OpEq32F_0(v *Value) bool {
1460	// match: (Eq32F x y)
1461	// result: (F32Eq x y)
1462	for {
1463		y := v.Args[1]
1464		x := v.Args[0]
1465		v.reset(OpWasmF32Eq)
1466		v.AddArg(x)
1467		v.AddArg(y)
1468		return true
1469	}
1470}
1471func rewriteValueWasm_OpEq64_0(v *Value) bool {
1472	// match: (Eq64 x y)
1473	// result: (I64Eq x y)
1474	for {
1475		y := v.Args[1]
1476		x := v.Args[0]
1477		v.reset(OpWasmI64Eq)
1478		v.AddArg(x)
1479		v.AddArg(y)
1480		return true
1481	}
1482}
1483func rewriteValueWasm_OpEq64F_0(v *Value) bool {
1484	// match: (Eq64F x y)
1485	// result: (F64Eq x y)
1486	for {
1487		y := v.Args[1]
1488		x := v.Args[0]
1489		v.reset(OpWasmF64Eq)
1490		v.AddArg(x)
1491		v.AddArg(y)
1492		return true
1493	}
1494}
1495func rewriteValueWasm_OpEq8_0(v *Value) bool {
1496	b := v.Block
1497	typ := &b.Func.Config.Types
1498	// match: (Eq8 x y)
1499	// result: (I64Eq (ZeroExt8to64 x) (ZeroExt8to64 y))
1500	for {
1501		y := v.Args[1]
1502		x := v.Args[0]
1503		v.reset(OpWasmI64Eq)
1504		v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
1505		v0.AddArg(x)
1506		v.AddArg(v0)
1507		v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
1508		v1.AddArg(y)
1509		v.AddArg(v1)
1510		return true
1511	}
1512}
1513func rewriteValueWasm_OpEqB_0(v *Value) bool {
1514	// match: (EqB x y)
1515	// result: (I64Eq x y)
1516	for {
1517		y := v.Args[1]
1518		x := v.Args[0]
1519		v.reset(OpWasmI64Eq)
1520		v.AddArg(x)
1521		v.AddArg(y)
1522		return true
1523	}
1524}
1525func rewriteValueWasm_OpEqPtr_0(v *Value) bool {
1526	// match: (EqPtr x y)
1527	// result: (I64Eq x y)
1528	for {
1529		y := v.Args[1]
1530		x := v.Args[0]
1531		v.reset(OpWasmI64Eq)
1532		v.AddArg(x)
1533		v.AddArg(y)
1534		return true
1535	}
1536}
1537func rewriteValueWasm_OpFloor_0(v *Value) bool {
1538	// match: (Floor x)
1539	// result: (F64Floor x)
1540	for {
1541		x := v.Args[0]
1542		v.reset(OpWasmF64Floor)
1543		v.AddArg(x)
1544		return true
1545	}
1546}
1547func rewriteValueWasm_OpGeq16_0(v *Value) bool {
1548	b := v.Block
1549	typ := &b.Func.Config.Types
1550	// match: (Geq16 x y)
1551	// result: (I64GeS (SignExt16to64 x) (SignExt16to64 y))
1552	for {
1553		y := v.Args[1]
1554		x := v.Args[0]
1555		v.reset(OpWasmI64GeS)
1556		v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
1557		v0.AddArg(x)
1558		v.AddArg(v0)
1559		v1 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
1560		v1.AddArg(y)
1561		v.AddArg(v1)
1562		return true
1563	}
1564}
1565func rewriteValueWasm_OpGeq16U_0(v *Value) bool {
1566	b := v.Block
1567	typ := &b.Func.Config.Types
1568	// match: (Geq16U x y)
1569	// result: (I64GeU (ZeroExt16to64 x) (ZeroExt16to64 y))
1570	for {
1571		y := v.Args[1]
1572		x := v.Args[0]
1573		v.reset(OpWasmI64GeU)
1574		v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
1575		v0.AddArg(x)
1576		v.AddArg(v0)
1577		v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
1578		v1.AddArg(y)
1579		v.AddArg(v1)
1580		return true
1581	}
1582}
1583func rewriteValueWasm_OpGeq32_0(v *Value) bool {
1584	b := v.Block
1585	typ := &b.Func.Config.Types
1586	// match: (Geq32 x y)
1587	// result: (I64GeS (SignExt32to64 x) (SignExt32to64 y))
1588	for {
1589		y := v.Args[1]
1590		x := v.Args[0]
1591		v.reset(OpWasmI64GeS)
1592		v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
1593		v0.AddArg(x)
1594		v.AddArg(v0)
1595		v1 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
1596		v1.AddArg(y)
1597		v.AddArg(v1)
1598		return true
1599	}
1600}
1601func rewriteValueWasm_OpGeq32F_0(v *Value) bool {
1602	// match: (Geq32F x y)
1603	// result: (F32Ge x y)
1604	for {
1605		y := v.Args[1]
1606		x := v.Args[0]
1607		v.reset(OpWasmF32Ge)
1608		v.AddArg(x)
1609		v.AddArg(y)
1610		return true
1611	}
1612}
1613func rewriteValueWasm_OpGeq32U_0(v *Value) bool {
1614	b := v.Block
1615	typ := &b.Func.Config.Types
1616	// match: (Geq32U x y)
1617	// result: (I64GeU (ZeroExt32to64 x) (ZeroExt32to64 y))
1618	for {
1619		y := v.Args[1]
1620		x := v.Args[0]
1621		v.reset(OpWasmI64GeU)
1622		v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
1623		v0.AddArg(x)
1624		v.AddArg(v0)
1625		v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
1626		v1.AddArg(y)
1627		v.AddArg(v1)
1628		return true
1629	}
1630}
1631func rewriteValueWasm_OpGeq64_0(v *Value) bool {
1632	// match: (Geq64 x y)
1633	// result: (I64GeS x y)
1634	for {
1635		y := v.Args[1]
1636		x := v.Args[0]
1637		v.reset(OpWasmI64GeS)
1638		v.AddArg(x)
1639		v.AddArg(y)
1640		return true
1641	}
1642}
1643func rewriteValueWasm_OpGeq64F_0(v *Value) bool {
1644	// match: (Geq64F x y)
1645	// result: (F64Ge x y)
1646	for {
1647		y := v.Args[1]
1648		x := v.Args[0]
1649		v.reset(OpWasmF64Ge)
1650		v.AddArg(x)
1651		v.AddArg(y)
1652		return true
1653	}
1654}
1655func rewriteValueWasm_OpGeq64U_0(v *Value) bool {
1656	// match: (Geq64U x y)
1657	// result: (I64GeU x y)
1658	for {
1659		y := v.Args[1]
1660		x := v.Args[0]
1661		v.reset(OpWasmI64GeU)
1662		v.AddArg(x)
1663		v.AddArg(y)
1664		return true
1665	}
1666}
1667func rewriteValueWasm_OpGeq8_0(v *Value) bool {
1668	b := v.Block
1669	typ := &b.Func.Config.Types
1670	// match: (Geq8 x y)
1671	// result: (I64GeS (SignExt8to64 x) (SignExt8to64 y))
1672	for {
1673		y := v.Args[1]
1674		x := v.Args[0]
1675		v.reset(OpWasmI64GeS)
1676		v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
1677		v0.AddArg(x)
1678		v.AddArg(v0)
1679		v1 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
1680		v1.AddArg(y)
1681		v.AddArg(v1)
1682		return true
1683	}
1684}
1685func rewriteValueWasm_OpGeq8U_0(v *Value) bool {
1686	b := v.Block
1687	typ := &b.Func.Config.Types
1688	// match: (Geq8U x y)
1689	// result: (I64GeU (ZeroExt8to64 x) (ZeroExt8to64 y))
1690	for {
1691		y := v.Args[1]
1692		x := v.Args[0]
1693		v.reset(OpWasmI64GeU)
1694		v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
1695		v0.AddArg(x)
1696		v.AddArg(v0)
1697		v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
1698		v1.AddArg(y)
1699		v.AddArg(v1)
1700		return true
1701	}
1702}
1703func rewriteValueWasm_OpGetCallerPC_0(v *Value) bool {
1704	// match: (GetCallerPC)
1705	// result: (LoweredGetCallerPC)
1706	for {
1707		v.reset(OpWasmLoweredGetCallerPC)
1708		return true
1709	}
1710}
1711func rewriteValueWasm_OpGetCallerSP_0(v *Value) bool {
1712	// match: (GetCallerSP)
1713	// result: (LoweredGetCallerSP)
1714	for {
1715		v.reset(OpWasmLoweredGetCallerSP)
1716		return true
1717	}
1718}
1719func rewriteValueWasm_OpGetClosurePtr_0(v *Value) bool {
1720	// match: (GetClosurePtr)
1721	// result: (LoweredGetClosurePtr)
1722	for {
1723		v.reset(OpWasmLoweredGetClosurePtr)
1724		return true
1725	}
1726}
1727func rewriteValueWasm_OpGreater16_0(v *Value) bool {
1728	b := v.Block
1729	typ := &b.Func.Config.Types
1730	// match: (Greater16 x y)
1731	// result: (I64GtS (SignExt16to64 x) (SignExt16to64 y))
1732	for {
1733		y := v.Args[1]
1734		x := v.Args[0]
1735		v.reset(OpWasmI64GtS)
1736		v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
1737		v0.AddArg(x)
1738		v.AddArg(v0)
1739		v1 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
1740		v1.AddArg(y)
1741		v.AddArg(v1)
1742		return true
1743	}
1744}
1745func rewriteValueWasm_OpGreater16U_0(v *Value) bool {
1746	b := v.Block
1747	typ := &b.Func.Config.Types
1748	// match: (Greater16U x y)
1749	// result: (I64GtU (ZeroExt16to64 x) (ZeroExt16to64 y))
1750	for {
1751		y := v.Args[1]
1752		x := v.Args[0]
1753		v.reset(OpWasmI64GtU)
1754		v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
1755		v0.AddArg(x)
1756		v.AddArg(v0)
1757		v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
1758		v1.AddArg(y)
1759		v.AddArg(v1)
1760		return true
1761	}
1762}
1763func rewriteValueWasm_OpGreater32_0(v *Value) bool {
1764	b := v.Block
1765	typ := &b.Func.Config.Types
1766	// match: (Greater32 x y)
1767	// result: (I64GtS (SignExt32to64 x) (SignExt32to64 y))
1768	for {
1769		y := v.Args[1]
1770		x := v.Args[0]
1771		v.reset(OpWasmI64GtS)
1772		v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
1773		v0.AddArg(x)
1774		v.AddArg(v0)
1775		v1 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
1776		v1.AddArg(y)
1777		v.AddArg(v1)
1778		return true
1779	}
1780}
1781func rewriteValueWasm_OpGreater32F_0(v *Value) bool {
1782	// match: (Greater32F x y)
1783	// result: (F32Gt x y)
1784	for {
1785		y := v.Args[1]
1786		x := v.Args[0]
1787		v.reset(OpWasmF32Gt)
1788		v.AddArg(x)
1789		v.AddArg(y)
1790		return true
1791	}
1792}
1793func rewriteValueWasm_OpGreater32U_0(v *Value) bool {
1794	b := v.Block
1795	typ := &b.Func.Config.Types
1796	// match: (Greater32U x y)
1797	// result: (I64GtU (ZeroExt32to64 x) (ZeroExt32to64 y))
1798	for {
1799		y := v.Args[1]
1800		x := v.Args[0]
1801		v.reset(OpWasmI64GtU)
1802		v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
1803		v0.AddArg(x)
1804		v.AddArg(v0)
1805		v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
1806		v1.AddArg(y)
1807		v.AddArg(v1)
1808		return true
1809	}
1810}
1811func rewriteValueWasm_OpGreater64_0(v *Value) bool {
1812	// match: (Greater64 x y)
1813	// result: (I64GtS x y)
1814	for {
1815		y := v.Args[1]
1816		x := v.Args[0]
1817		v.reset(OpWasmI64GtS)
1818		v.AddArg(x)
1819		v.AddArg(y)
1820		return true
1821	}
1822}
1823func rewriteValueWasm_OpGreater64F_0(v *Value) bool {
1824	// match: (Greater64F x y)
1825	// result: (F64Gt x y)
1826	for {
1827		y := v.Args[1]
1828		x := v.Args[0]
1829		v.reset(OpWasmF64Gt)
1830		v.AddArg(x)
1831		v.AddArg(y)
1832		return true
1833	}
1834}
1835func rewriteValueWasm_OpGreater64U_0(v *Value) bool {
1836	// match: (Greater64U x y)
1837	// result: (I64GtU x y)
1838	for {
1839		y := v.Args[1]
1840		x := v.Args[0]
1841		v.reset(OpWasmI64GtU)
1842		v.AddArg(x)
1843		v.AddArg(y)
1844		return true
1845	}
1846}
1847func rewriteValueWasm_OpGreater8_0(v *Value) bool {
1848	b := v.Block
1849	typ := &b.Func.Config.Types
1850	// match: (Greater8 x y)
1851	// result: (I64GtS (SignExt8to64 x) (SignExt8to64 y))
1852	for {
1853		y := v.Args[1]
1854		x := v.Args[0]
1855		v.reset(OpWasmI64GtS)
1856		v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
1857		v0.AddArg(x)
1858		v.AddArg(v0)
1859		v1 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
1860		v1.AddArg(y)
1861		v.AddArg(v1)
1862		return true
1863	}
1864}
1865func rewriteValueWasm_OpGreater8U_0(v *Value) bool {
1866	b := v.Block
1867	typ := &b.Func.Config.Types
1868	// match: (Greater8U x y)
1869	// result: (I64GtU (ZeroExt8to64 x) (ZeroExt8to64 y))
1870	for {
1871		y := v.Args[1]
1872		x := v.Args[0]
1873		v.reset(OpWasmI64GtU)
1874		v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
1875		v0.AddArg(x)
1876		v.AddArg(v0)
1877		v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
1878		v1.AddArg(y)
1879		v.AddArg(v1)
1880		return true
1881	}
1882}
1883func rewriteValueWasm_OpInterCall_0(v *Value) bool {
1884	// match: (InterCall [argwid] entry mem)
1885	// result: (LoweredInterCall [argwid] entry mem)
1886	for {
1887		argwid := v.AuxInt
1888		mem := v.Args[1]
1889		entry := v.Args[0]
1890		v.reset(OpWasmLoweredInterCall)
1891		v.AuxInt = argwid
1892		v.AddArg(entry)
1893		v.AddArg(mem)
1894		return true
1895	}
1896}
1897func rewriteValueWasm_OpIsInBounds_0(v *Value) bool {
1898	// match: (IsInBounds idx len)
1899	// result: (I64LtU idx len)
1900	for {
1901		len := v.Args[1]
1902		idx := v.Args[0]
1903		v.reset(OpWasmI64LtU)
1904		v.AddArg(idx)
1905		v.AddArg(len)
1906		return true
1907	}
1908}
1909func rewriteValueWasm_OpIsNonNil_0(v *Value) bool {
1910	b := v.Block
1911	typ := &b.Func.Config.Types
1912	// match: (IsNonNil p)
1913	// result: (I64Eqz (I64Eqz p))
1914	for {
1915		p := v.Args[0]
1916		v.reset(OpWasmI64Eqz)
1917		v0 := b.NewValue0(v.Pos, OpWasmI64Eqz, typ.Bool)
1918		v0.AddArg(p)
1919		v.AddArg(v0)
1920		return true
1921	}
1922}
1923func rewriteValueWasm_OpIsSliceInBounds_0(v *Value) bool {
1924	// match: (IsSliceInBounds idx len)
1925	// result: (I64LeU idx len)
1926	for {
1927		len := v.Args[1]
1928		idx := v.Args[0]
1929		v.reset(OpWasmI64LeU)
1930		v.AddArg(idx)
1931		v.AddArg(len)
1932		return true
1933	}
1934}
1935func rewriteValueWasm_OpLeq16_0(v *Value) bool {
1936	b := v.Block
1937	typ := &b.Func.Config.Types
1938	// match: (Leq16 x y)
1939	// result: (I64LeS (SignExt16to64 x) (SignExt16to64 y))
1940	for {
1941		y := v.Args[1]
1942		x := v.Args[0]
1943		v.reset(OpWasmI64LeS)
1944		v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
1945		v0.AddArg(x)
1946		v.AddArg(v0)
1947		v1 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
1948		v1.AddArg(y)
1949		v.AddArg(v1)
1950		return true
1951	}
1952}
1953func rewriteValueWasm_OpLeq16U_0(v *Value) bool {
1954	b := v.Block
1955	typ := &b.Func.Config.Types
1956	// match: (Leq16U x y)
1957	// result: (I64LeU (ZeroExt16to64 x) (ZeroExt16to64 y))
1958	for {
1959		y := v.Args[1]
1960		x := v.Args[0]
1961		v.reset(OpWasmI64LeU)
1962		v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
1963		v0.AddArg(x)
1964		v.AddArg(v0)
1965		v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
1966		v1.AddArg(y)
1967		v.AddArg(v1)
1968		return true
1969	}
1970}
1971func rewriteValueWasm_OpLeq32_0(v *Value) bool {
1972	b := v.Block
1973	typ := &b.Func.Config.Types
1974	// match: (Leq32 x y)
1975	// result: (I64LeS (SignExt32to64 x) (SignExt32to64 y))
1976	for {
1977		y := v.Args[1]
1978		x := v.Args[0]
1979		v.reset(OpWasmI64LeS)
1980		v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
1981		v0.AddArg(x)
1982		v.AddArg(v0)
1983		v1 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
1984		v1.AddArg(y)
1985		v.AddArg(v1)
1986		return true
1987	}
1988}
1989func rewriteValueWasm_OpLeq32F_0(v *Value) bool {
1990	// match: (Leq32F x y)
1991	// result: (F32Le x y)
1992	for {
1993		y := v.Args[1]
1994		x := v.Args[0]
1995		v.reset(OpWasmF32Le)
1996		v.AddArg(x)
1997		v.AddArg(y)
1998		return true
1999	}
2000}
2001func rewriteValueWasm_OpLeq32U_0(v *Value) bool {
2002	b := v.Block
2003	typ := &b.Func.Config.Types
2004	// match: (Leq32U x y)
2005	// result: (I64LeU (ZeroExt32to64 x) (ZeroExt32to64 y))
2006	for {
2007		y := v.Args[1]
2008		x := v.Args[0]
2009		v.reset(OpWasmI64LeU)
2010		v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
2011		v0.AddArg(x)
2012		v.AddArg(v0)
2013		v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
2014		v1.AddArg(y)
2015		v.AddArg(v1)
2016		return true
2017	}
2018}
2019func rewriteValueWasm_OpLeq64_0(v *Value) bool {
2020	// match: (Leq64 x y)
2021	// result: (I64LeS x y)
2022	for {
2023		y := v.Args[1]
2024		x := v.Args[0]
2025		v.reset(OpWasmI64LeS)
2026		v.AddArg(x)
2027		v.AddArg(y)
2028		return true
2029	}
2030}
2031func rewriteValueWasm_OpLeq64F_0(v *Value) bool {
2032	// match: (Leq64F x y)
2033	// result: (F64Le x y)
2034	for {
2035		y := v.Args[1]
2036		x := v.Args[0]
2037		v.reset(OpWasmF64Le)
2038		v.AddArg(x)
2039		v.AddArg(y)
2040		return true
2041	}
2042}
2043func rewriteValueWasm_OpLeq64U_0(v *Value) bool {
2044	// match: (Leq64U x y)
2045	// result: (I64LeU x y)
2046	for {
2047		y := v.Args[1]
2048		x := v.Args[0]
2049		v.reset(OpWasmI64LeU)
2050		v.AddArg(x)
2051		v.AddArg(y)
2052		return true
2053	}
2054}
2055func rewriteValueWasm_OpLeq8_0(v *Value) bool {
2056	b := v.Block
2057	typ := &b.Func.Config.Types
2058	// match: (Leq8 x y)
2059	// result: (I64LeS (SignExt8to64 x) (SignExt8to64 y))
2060	for {
2061		y := v.Args[1]
2062		x := v.Args[0]
2063		v.reset(OpWasmI64LeS)
2064		v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
2065		v0.AddArg(x)
2066		v.AddArg(v0)
2067		v1 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
2068		v1.AddArg(y)
2069		v.AddArg(v1)
2070		return true
2071	}
2072}
2073func rewriteValueWasm_OpLeq8U_0(v *Value) bool {
2074	b := v.Block
2075	typ := &b.Func.Config.Types
2076	// match: (Leq8U x y)
2077	// result: (I64LeU (ZeroExt8to64 x) (ZeroExt8to64 y))
2078	for {
2079		y := v.Args[1]
2080		x := v.Args[0]
2081		v.reset(OpWasmI64LeU)
2082		v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
2083		v0.AddArg(x)
2084		v.AddArg(v0)
2085		v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
2086		v1.AddArg(y)
2087		v.AddArg(v1)
2088		return true
2089	}
2090}
2091func rewriteValueWasm_OpLess16_0(v *Value) bool {
2092	b := v.Block
2093	typ := &b.Func.Config.Types
2094	// match: (Less16 x y)
2095	// result: (I64LtS (SignExt16to64 x) (SignExt16to64 y))
2096	for {
2097		y := v.Args[1]
2098		x := v.Args[0]
2099		v.reset(OpWasmI64LtS)
2100		v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
2101		v0.AddArg(x)
2102		v.AddArg(v0)
2103		v1 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
2104		v1.AddArg(y)
2105		v.AddArg(v1)
2106		return true
2107	}
2108}
2109func rewriteValueWasm_OpLess16U_0(v *Value) bool {
2110	b := v.Block
2111	typ := &b.Func.Config.Types
2112	// match: (Less16U x y)
2113	// result: (I64LtU (ZeroExt16to64 x) (ZeroExt16to64 y))
2114	for {
2115		y := v.Args[1]
2116		x := v.Args[0]
2117		v.reset(OpWasmI64LtU)
2118		v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
2119		v0.AddArg(x)
2120		v.AddArg(v0)
2121		v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
2122		v1.AddArg(y)
2123		v.AddArg(v1)
2124		return true
2125	}
2126}
2127func rewriteValueWasm_OpLess32_0(v *Value) bool {
2128	b := v.Block
2129	typ := &b.Func.Config.Types
2130	// match: (Less32 x y)
2131	// result: (I64LtS (SignExt32to64 x) (SignExt32to64 y))
2132	for {
2133		y := v.Args[1]
2134		x := v.Args[0]
2135		v.reset(OpWasmI64LtS)
2136		v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
2137		v0.AddArg(x)
2138		v.AddArg(v0)
2139		v1 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
2140		v1.AddArg(y)
2141		v.AddArg(v1)
2142		return true
2143	}
2144}
2145func rewriteValueWasm_OpLess32F_0(v *Value) bool {
2146	// match: (Less32F x y)
2147	// result: (F32Lt x y)
2148	for {
2149		y := v.Args[1]
2150		x := v.Args[0]
2151		v.reset(OpWasmF32Lt)
2152		v.AddArg(x)
2153		v.AddArg(y)
2154		return true
2155	}
2156}
2157func rewriteValueWasm_OpLess32U_0(v *Value) bool {
2158	b := v.Block
2159	typ := &b.Func.Config.Types
2160	// match: (Less32U x y)
2161	// result: (I64LtU (ZeroExt32to64 x) (ZeroExt32to64 y))
2162	for {
2163		y := v.Args[1]
2164		x := v.Args[0]
2165		v.reset(OpWasmI64LtU)
2166		v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
2167		v0.AddArg(x)
2168		v.AddArg(v0)
2169		v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
2170		v1.AddArg(y)
2171		v.AddArg(v1)
2172		return true
2173	}
2174}
2175func rewriteValueWasm_OpLess64_0(v *Value) bool {
2176	// match: (Less64 x y)
2177	// result: (I64LtS x y)
2178	for {
2179		y := v.Args[1]
2180		x := v.Args[0]
2181		v.reset(OpWasmI64LtS)
2182		v.AddArg(x)
2183		v.AddArg(y)
2184		return true
2185	}
2186}
2187func rewriteValueWasm_OpLess64F_0(v *Value) bool {
2188	// match: (Less64F x y)
2189	// result: (F64Lt x y)
2190	for {
2191		y := v.Args[1]
2192		x := v.Args[0]
2193		v.reset(OpWasmF64Lt)
2194		v.AddArg(x)
2195		v.AddArg(y)
2196		return true
2197	}
2198}
2199func rewriteValueWasm_OpLess64U_0(v *Value) bool {
2200	// match: (Less64U x y)
2201	// result: (I64LtU x y)
2202	for {
2203		y := v.Args[1]
2204		x := v.Args[0]
2205		v.reset(OpWasmI64LtU)
2206		v.AddArg(x)
2207		v.AddArg(y)
2208		return true
2209	}
2210}
2211func rewriteValueWasm_OpLess8_0(v *Value) bool {
2212	b := v.Block
2213	typ := &b.Func.Config.Types
2214	// match: (Less8 x y)
2215	// result: (I64LtS (SignExt8to64 x) (SignExt8to64 y))
2216	for {
2217		y := v.Args[1]
2218		x := v.Args[0]
2219		v.reset(OpWasmI64LtS)
2220		v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
2221		v0.AddArg(x)
2222		v.AddArg(v0)
2223		v1 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
2224		v1.AddArg(y)
2225		v.AddArg(v1)
2226		return true
2227	}
2228}
2229func rewriteValueWasm_OpLess8U_0(v *Value) bool {
2230	b := v.Block
2231	typ := &b.Func.Config.Types
2232	// match: (Less8U x y)
2233	// result: (I64LtU (ZeroExt8to64 x) (ZeroExt8to64 y))
2234	for {
2235		y := v.Args[1]
2236		x := v.Args[0]
2237		v.reset(OpWasmI64LtU)
2238		v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
2239		v0.AddArg(x)
2240		v.AddArg(v0)
2241		v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
2242		v1.AddArg(y)
2243		v.AddArg(v1)
2244		return true
2245	}
2246}
2247func rewriteValueWasm_OpLoad_0(v *Value) bool {
2248	// match: (Load <t> ptr mem)
2249	// cond: is32BitFloat(t)
2250	// result: (F32Load ptr mem)
2251	for {
2252		t := v.Type
2253		mem := v.Args[1]
2254		ptr := v.Args[0]
2255		if !(is32BitFloat(t)) {
2256			break
2257		}
2258		v.reset(OpWasmF32Load)
2259		v.AddArg(ptr)
2260		v.AddArg(mem)
2261		return true
2262	}
2263	// match: (Load <t> ptr mem)
2264	// cond: is64BitFloat(t)
2265	// result: (F64Load ptr mem)
2266	for {
2267		t := v.Type
2268		mem := v.Args[1]
2269		ptr := v.Args[0]
2270		if !(is64BitFloat(t)) {
2271			break
2272		}
2273		v.reset(OpWasmF64Load)
2274		v.AddArg(ptr)
2275		v.AddArg(mem)
2276		return true
2277	}
2278	// match: (Load <t> ptr mem)
2279	// cond: t.Size() == 8
2280	// result: (I64Load ptr mem)
2281	for {
2282		t := v.Type
2283		mem := v.Args[1]
2284		ptr := v.Args[0]
2285		if !(t.Size() == 8) {
2286			break
2287		}
2288		v.reset(OpWasmI64Load)
2289		v.AddArg(ptr)
2290		v.AddArg(mem)
2291		return true
2292	}
2293	// match: (Load <t> ptr mem)
2294	// cond: t.Size() == 4 && !t.IsSigned()
2295	// result: (I64Load32U ptr mem)
2296	for {
2297		t := v.Type
2298		mem := v.Args[1]
2299		ptr := v.Args[0]
2300		if !(t.Size() == 4 && !t.IsSigned()) {
2301			break
2302		}
2303		v.reset(OpWasmI64Load32U)
2304		v.AddArg(ptr)
2305		v.AddArg(mem)
2306		return true
2307	}
2308	// match: (Load <t> ptr mem)
2309	// cond: t.Size() == 4 && t.IsSigned()
2310	// result: (I64Load32S ptr mem)
2311	for {
2312		t := v.Type
2313		mem := v.Args[1]
2314		ptr := v.Args[0]
2315		if !(t.Size() == 4 && t.IsSigned()) {
2316			break
2317		}
2318		v.reset(OpWasmI64Load32S)
2319		v.AddArg(ptr)
2320		v.AddArg(mem)
2321		return true
2322	}
2323	// match: (Load <t> ptr mem)
2324	// cond: t.Size() == 2 && !t.IsSigned()
2325	// result: (I64Load16U ptr mem)
2326	for {
2327		t := v.Type
2328		mem := v.Args[1]
2329		ptr := v.Args[0]
2330		if !(t.Size() == 2 && !t.IsSigned()) {
2331			break
2332		}
2333		v.reset(OpWasmI64Load16U)
2334		v.AddArg(ptr)
2335		v.AddArg(mem)
2336		return true
2337	}
2338	// match: (Load <t> ptr mem)
2339	// cond: t.Size() == 2 && t.IsSigned()
2340	// result: (I64Load16S ptr mem)
2341	for {
2342		t := v.Type
2343		mem := v.Args[1]
2344		ptr := v.Args[0]
2345		if !(t.Size() == 2 && t.IsSigned()) {
2346			break
2347		}
2348		v.reset(OpWasmI64Load16S)
2349		v.AddArg(ptr)
2350		v.AddArg(mem)
2351		return true
2352	}
2353	// match: (Load <t> ptr mem)
2354	// cond: t.Size() == 1 && !t.IsSigned()
2355	// result: (I64Load8U ptr mem)
2356	for {
2357		t := v.Type
2358		mem := v.Args[1]
2359		ptr := v.Args[0]
2360		if !(t.Size() == 1 && !t.IsSigned()) {
2361			break
2362		}
2363		v.reset(OpWasmI64Load8U)
2364		v.AddArg(ptr)
2365		v.AddArg(mem)
2366		return true
2367	}
2368	// match: (Load <t> ptr mem)
2369	// cond: t.Size() == 1 && t.IsSigned()
2370	// result: (I64Load8S ptr mem)
2371	for {
2372		t := v.Type
2373		mem := v.Args[1]
2374		ptr := v.Args[0]
2375		if !(t.Size() == 1 && t.IsSigned()) {
2376			break
2377		}
2378		v.reset(OpWasmI64Load8S)
2379		v.AddArg(ptr)
2380		v.AddArg(mem)
2381		return true
2382	}
2383	return false
2384}
2385func rewriteValueWasm_OpLocalAddr_0(v *Value) bool {
2386	// match: (LocalAddr {sym} base _)
2387	// result: (LoweredAddr {sym} base)
2388	for {
2389		sym := v.Aux
2390		_ = v.Args[1]
2391		base := v.Args[0]
2392		v.reset(OpWasmLoweredAddr)
2393		v.Aux = sym
2394		v.AddArg(base)
2395		return true
2396	}
2397}
2398func rewriteValueWasm_OpLsh16x16_0(v *Value) bool {
2399	b := v.Block
2400	typ := &b.Func.Config.Types
2401	// match: (Lsh16x16 x y)
2402	// result: (Lsh64x64 x (ZeroExt16to64 y))
2403	for {
2404		y := v.Args[1]
2405		x := v.Args[0]
2406		v.reset(OpLsh64x64)
2407		v.AddArg(x)
2408		v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
2409		v0.AddArg(y)
2410		v.AddArg(v0)
2411		return true
2412	}
2413}
2414func rewriteValueWasm_OpLsh16x32_0(v *Value) bool {
2415	b := v.Block
2416	typ := &b.Func.Config.Types
2417	// match: (Lsh16x32 x y)
2418	// result: (Lsh64x64 x (ZeroExt32to64 y))
2419	for {
2420		y := v.Args[1]
2421		x := v.Args[0]
2422		v.reset(OpLsh64x64)
2423		v.AddArg(x)
2424		v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
2425		v0.AddArg(y)
2426		v.AddArg(v0)
2427		return true
2428	}
2429}
2430func rewriteValueWasm_OpLsh16x64_0(v *Value) bool {
2431	// match: (Lsh16x64 x y)
2432	// result: (Lsh64x64 x y)
2433	for {
2434		y := v.Args[1]
2435		x := v.Args[0]
2436		v.reset(OpLsh64x64)
2437		v.AddArg(x)
2438		v.AddArg(y)
2439		return true
2440	}
2441}
2442func rewriteValueWasm_OpLsh16x8_0(v *Value) bool {
2443	b := v.Block
2444	typ := &b.Func.Config.Types
2445	// match: (Lsh16x8 x y)
2446	// result: (Lsh64x64 x (ZeroExt8to64 y))
2447	for {
2448		y := v.Args[1]
2449		x := v.Args[0]
2450		v.reset(OpLsh64x64)
2451		v.AddArg(x)
2452		v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
2453		v0.AddArg(y)
2454		v.AddArg(v0)
2455		return true
2456	}
2457}
2458func rewriteValueWasm_OpLsh32x16_0(v *Value) bool {
2459	b := v.Block
2460	typ := &b.Func.Config.Types
2461	// match: (Lsh32x16 x y)
2462	// result: (Lsh64x64 x (ZeroExt16to64 y))
2463	for {
2464		y := v.Args[1]
2465		x := v.Args[0]
2466		v.reset(OpLsh64x64)
2467		v.AddArg(x)
2468		v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
2469		v0.AddArg(y)
2470		v.AddArg(v0)
2471		return true
2472	}
2473}
2474func rewriteValueWasm_OpLsh32x32_0(v *Value) bool {
2475	b := v.Block
2476	typ := &b.Func.Config.Types
2477	// match: (Lsh32x32 x y)
2478	// result: (Lsh64x64 x (ZeroExt32to64 y))
2479	for {
2480		y := v.Args[1]
2481		x := v.Args[0]
2482		v.reset(OpLsh64x64)
2483		v.AddArg(x)
2484		v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
2485		v0.AddArg(y)
2486		v.AddArg(v0)
2487		return true
2488	}
2489}
2490func rewriteValueWasm_OpLsh32x64_0(v *Value) bool {
2491	// match: (Lsh32x64 x y)
2492	// result: (Lsh64x64 x y)
2493	for {
2494		y := v.Args[1]
2495		x := v.Args[0]
2496		v.reset(OpLsh64x64)
2497		v.AddArg(x)
2498		v.AddArg(y)
2499		return true
2500	}
2501}
2502func rewriteValueWasm_OpLsh32x8_0(v *Value) bool {
2503	b := v.Block
2504	typ := &b.Func.Config.Types
2505	// match: (Lsh32x8 x y)
2506	// result: (Lsh64x64 x (ZeroExt8to64 y))
2507	for {
2508		y := v.Args[1]
2509		x := v.Args[0]
2510		v.reset(OpLsh64x64)
2511		v.AddArg(x)
2512		v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
2513		v0.AddArg(y)
2514		v.AddArg(v0)
2515		return true
2516	}
2517}
2518func rewriteValueWasm_OpLsh64x16_0(v *Value) bool {
2519	b := v.Block
2520	typ := &b.Func.Config.Types
2521	// match: (Lsh64x16 x y)
2522	// result: (Lsh64x64 x (ZeroExt16to64 y))
2523	for {
2524		y := v.Args[1]
2525		x := v.Args[0]
2526		v.reset(OpLsh64x64)
2527		v.AddArg(x)
2528		v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
2529		v0.AddArg(y)
2530		v.AddArg(v0)
2531		return true
2532	}
2533}
2534func rewriteValueWasm_OpLsh64x32_0(v *Value) bool {
2535	b := v.Block
2536	typ := &b.Func.Config.Types
2537	// match: (Lsh64x32 x y)
2538	// result: (Lsh64x64 x (ZeroExt32to64 y))
2539	for {
2540		y := v.Args[1]
2541		x := v.Args[0]
2542		v.reset(OpLsh64x64)
2543		v.AddArg(x)
2544		v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
2545		v0.AddArg(y)
2546		v.AddArg(v0)
2547		return true
2548	}
2549}
2550func rewriteValueWasm_OpLsh64x64_0(v *Value) bool {
2551	b := v.Block
2552	typ := &b.Func.Config.Types
2553	// match: (Lsh64x64 x y)
2554	// cond: shiftIsBounded(v)
2555	// result: (I64Shl x y)
2556	for {
2557		y := v.Args[1]
2558		x := v.Args[0]
2559		if !(shiftIsBounded(v)) {
2560			break
2561		}
2562		v.reset(OpWasmI64Shl)
2563		v.AddArg(x)
2564		v.AddArg(y)
2565		return true
2566	}
2567	// match: (Lsh64x64 x (I64Const [c]))
2568	// cond: uint64(c) < 64
2569	// result: (I64Shl x (I64Const [c]))
2570	for {
2571		_ = v.Args[1]
2572		x := v.Args[0]
2573		v_1 := v.Args[1]
2574		if v_1.Op != OpWasmI64Const {
2575			break
2576		}
2577		c := v_1.AuxInt
2578		if !(uint64(c) < 64) {
2579			break
2580		}
2581		v.reset(OpWasmI64Shl)
2582		v.AddArg(x)
2583		v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
2584		v0.AuxInt = c
2585		v.AddArg(v0)
2586		return true
2587	}
2588	// match: (Lsh64x64 x (I64Const [c]))
2589	// cond: uint64(c) >= 64
2590	// result: (I64Const [0])
2591	for {
2592		_ = v.Args[1]
2593		v_1 := v.Args[1]
2594		if v_1.Op != OpWasmI64Const {
2595			break
2596		}
2597		c := v_1.AuxInt
2598		if !(uint64(c) >= 64) {
2599			break
2600		}
2601		v.reset(OpWasmI64Const)
2602		v.AuxInt = 0
2603		return true
2604	}
2605	// match: (Lsh64x64 x y)
2606	// result: (Select (I64Shl x y) (I64Const [0]) (I64LtU y (I64Const [64])))
2607	for {
2608		y := v.Args[1]
2609		x := v.Args[0]
2610		v.reset(OpWasmSelect)
2611		v0 := b.NewValue0(v.Pos, OpWasmI64Shl, typ.Int64)
2612		v0.AddArg(x)
2613		v0.AddArg(y)
2614		v.AddArg(v0)
2615		v1 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
2616		v1.AuxInt = 0
2617		v.AddArg(v1)
2618		v2 := b.NewValue0(v.Pos, OpWasmI64LtU, typ.Bool)
2619		v2.AddArg(y)
2620		v3 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
2621		v3.AuxInt = 64
2622		v2.AddArg(v3)
2623		v.AddArg(v2)
2624		return true
2625	}
2626}
2627func rewriteValueWasm_OpLsh64x8_0(v *Value) bool {
2628	b := v.Block
2629	typ := &b.Func.Config.Types
2630	// match: (Lsh64x8 x y)
2631	// result: (Lsh64x64 x (ZeroExt8to64 y))
2632	for {
2633		y := v.Args[1]
2634		x := v.Args[0]
2635		v.reset(OpLsh64x64)
2636		v.AddArg(x)
2637		v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
2638		v0.AddArg(y)
2639		v.AddArg(v0)
2640		return true
2641	}
2642}
2643func rewriteValueWasm_OpLsh8x16_0(v *Value) bool {
2644	b := v.Block
2645	typ := &b.Func.Config.Types
2646	// match: (Lsh8x16 x y)
2647	// result: (Lsh64x64 x (ZeroExt16to64 y))
2648	for {
2649		y := v.Args[1]
2650		x := v.Args[0]
2651		v.reset(OpLsh64x64)
2652		v.AddArg(x)
2653		v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
2654		v0.AddArg(y)
2655		v.AddArg(v0)
2656		return true
2657	}
2658}
2659func rewriteValueWasm_OpLsh8x32_0(v *Value) bool {
2660	b := v.Block
2661	typ := &b.Func.Config.Types
2662	// match: (Lsh8x32 x y)
2663	// result: (Lsh64x64 x (ZeroExt32to64 y))
2664	for {
2665		y := v.Args[1]
2666		x := v.Args[0]
2667		v.reset(OpLsh64x64)
2668		v.AddArg(x)
2669		v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
2670		v0.AddArg(y)
2671		v.AddArg(v0)
2672		return true
2673	}
2674}
2675func rewriteValueWasm_OpLsh8x64_0(v *Value) bool {
2676	// match: (Lsh8x64 x y)
2677	// result: (Lsh64x64 x y)
2678	for {
2679		y := v.Args[1]
2680		x := v.Args[0]
2681		v.reset(OpLsh64x64)
2682		v.AddArg(x)
2683		v.AddArg(y)
2684		return true
2685	}
2686}
2687func rewriteValueWasm_OpLsh8x8_0(v *Value) bool {
2688	b := v.Block
2689	typ := &b.Func.Config.Types
2690	// match: (Lsh8x8 x y)
2691	// result: (Lsh64x64 x (ZeroExt8to64 y))
2692	for {
2693		y := v.Args[1]
2694		x := v.Args[0]
2695		v.reset(OpLsh64x64)
2696		v.AddArg(x)
2697		v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
2698		v0.AddArg(y)
2699		v.AddArg(v0)
2700		return true
2701	}
2702}
2703func rewriteValueWasm_OpMod16_0(v *Value) bool {
2704	b := v.Block
2705	typ := &b.Func.Config.Types
2706	// match: (Mod16 x y)
2707	// result: (I64RemS (SignExt16to64 x) (SignExt16to64 y))
2708	for {
2709		y := v.Args[1]
2710		x := v.Args[0]
2711		v.reset(OpWasmI64RemS)
2712		v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
2713		v0.AddArg(x)
2714		v.AddArg(v0)
2715		v1 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
2716		v1.AddArg(y)
2717		v.AddArg(v1)
2718		return true
2719	}
2720}
2721func rewriteValueWasm_OpMod16u_0(v *Value) bool {
2722	b := v.Block
2723	typ := &b.Func.Config.Types
2724	// match: (Mod16u x y)
2725	// result: (I64RemU (ZeroExt16to64 x) (ZeroExt16to64 y))
2726	for {
2727		y := v.Args[1]
2728		x := v.Args[0]
2729		v.reset(OpWasmI64RemU)
2730		v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
2731		v0.AddArg(x)
2732		v.AddArg(v0)
2733		v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
2734		v1.AddArg(y)
2735		v.AddArg(v1)
2736		return true
2737	}
2738}
2739func rewriteValueWasm_OpMod32_0(v *Value) bool {
2740	b := v.Block
2741	typ := &b.Func.Config.Types
2742	// match: (Mod32 x y)
2743	// result: (I64RemS (SignExt32to64 x) (SignExt32to64 y))
2744	for {
2745		y := v.Args[1]
2746		x := v.Args[0]
2747		v.reset(OpWasmI64RemS)
2748		v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
2749		v0.AddArg(x)
2750		v.AddArg(v0)
2751		v1 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
2752		v1.AddArg(y)
2753		v.AddArg(v1)
2754		return true
2755	}
2756}
2757func rewriteValueWasm_OpMod32u_0(v *Value) bool {
2758	b := v.Block
2759	typ := &b.Func.Config.Types
2760	// match: (Mod32u x y)
2761	// result: (I64RemU (ZeroExt32to64 x) (ZeroExt32to64 y))
2762	for {
2763		y := v.Args[1]
2764		x := v.Args[0]
2765		v.reset(OpWasmI64RemU)
2766		v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
2767		v0.AddArg(x)
2768		v.AddArg(v0)
2769		v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
2770		v1.AddArg(y)
2771		v.AddArg(v1)
2772		return true
2773	}
2774}
2775func rewriteValueWasm_OpMod64_0(v *Value) bool {
2776	// match: (Mod64 x y)
2777	// result: (I64RemS x y)
2778	for {
2779		y := v.Args[1]
2780		x := v.Args[0]
2781		v.reset(OpWasmI64RemS)
2782		v.AddArg(x)
2783		v.AddArg(y)
2784		return true
2785	}
2786}
2787func rewriteValueWasm_OpMod64u_0(v *Value) bool {
2788	// match: (Mod64u x y)
2789	// result: (I64RemU x y)
2790	for {
2791		y := v.Args[1]
2792		x := v.Args[0]
2793		v.reset(OpWasmI64RemU)
2794		v.AddArg(x)
2795		v.AddArg(y)
2796		return true
2797	}
2798}
2799func rewriteValueWasm_OpMod8_0(v *Value) bool {
2800	b := v.Block
2801	typ := &b.Func.Config.Types
2802	// match: (Mod8 x y)
2803	// result: (I64RemS (SignExt8to64 x) (SignExt8to64 y))
2804	for {
2805		y := v.Args[1]
2806		x := v.Args[0]
2807		v.reset(OpWasmI64RemS)
2808		v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
2809		v0.AddArg(x)
2810		v.AddArg(v0)
2811		v1 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
2812		v1.AddArg(y)
2813		v.AddArg(v1)
2814		return true
2815	}
2816}
2817func rewriteValueWasm_OpMod8u_0(v *Value) bool {
2818	b := v.Block
2819	typ := &b.Func.Config.Types
2820	// match: (Mod8u x y)
2821	// result: (I64RemU (ZeroExt8to64 x) (ZeroExt8to64 y))
2822	for {
2823		y := v.Args[1]
2824		x := v.Args[0]
2825		v.reset(OpWasmI64RemU)
2826		v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
2827		v0.AddArg(x)
2828		v.AddArg(v0)
2829		v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
2830		v1.AddArg(y)
2831		v.AddArg(v1)
2832		return true
2833	}
2834}
2835func rewriteValueWasm_OpMove_0(v *Value) bool {
2836	b := v.Block
2837	typ := &b.Func.Config.Types
2838	// match: (Move [0] _ _ mem)
2839	// result: mem
2840	for {
2841		if v.AuxInt != 0 {
2842			break
2843		}
2844		mem := v.Args[2]
2845		v.reset(OpCopy)
2846		v.Type = mem.Type
2847		v.AddArg(mem)
2848		return true
2849	}
2850	// match: (Move [1] dst src mem)
2851	// result: (I64Store8 dst (I64Load8U src mem) mem)
2852	for {
2853		if v.AuxInt != 1 {
2854			break
2855		}
2856		mem := v.Args[2]
2857		dst := v.Args[0]
2858		src := v.Args[1]
2859		v.reset(OpWasmI64Store8)
2860		v.AddArg(dst)
2861		v0 := b.NewValue0(v.Pos, OpWasmI64Load8U, typ.UInt8)
2862		v0.AddArg(src)
2863		v0.AddArg(mem)
2864		v.AddArg(v0)
2865		v.AddArg(mem)
2866		return true
2867	}
2868	// match: (Move [2] dst src mem)
2869	// result: (I64Store16 dst (I64Load16U src mem) mem)
2870	for {
2871		if v.AuxInt != 2 {
2872			break
2873		}
2874		mem := v.Args[2]
2875		dst := v.Args[0]
2876		src := v.Args[1]
2877		v.reset(OpWasmI64Store16)
2878		v.AddArg(dst)
2879		v0 := b.NewValue0(v.Pos, OpWasmI64Load16U, typ.UInt16)
2880		v0.AddArg(src)
2881		v0.AddArg(mem)
2882		v.AddArg(v0)
2883		v.AddArg(mem)
2884		return true
2885	}
2886	// match: (Move [4] dst src mem)
2887	// result: (I64Store32 dst (I64Load32U src mem) mem)
2888	for {
2889		if v.AuxInt != 4 {
2890			break
2891		}
2892		mem := v.Args[2]
2893		dst := v.Args[0]
2894		src := v.Args[1]
2895		v.reset(OpWasmI64Store32)
2896		v.AddArg(dst)
2897		v0 := b.NewValue0(v.Pos, OpWasmI64Load32U, typ.UInt32)
2898		v0.AddArg(src)
2899		v0.AddArg(mem)
2900		v.AddArg(v0)
2901		v.AddArg(mem)
2902		return true
2903	}
2904	// match: (Move [8] dst src mem)
2905	// result: (I64Store dst (I64Load src mem) mem)
2906	for {
2907		if v.AuxInt != 8 {
2908			break
2909		}
2910		mem := v.Args[2]
2911		dst := v.Args[0]
2912		src := v.Args[1]
2913		v.reset(OpWasmI64Store)
2914		v.AddArg(dst)
2915		v0 := b.NewValue0(v.Pos, OpWasmI64Load, typ.UInt64)
2916		v0.AddArg(src)
2917		v0.AddArg(mem)
2918		v.AddArg(v0)
2919		v.AddArg(mem)
2920		return true
2921	}
2922	// match: (Move [16] dst src mem)
2923	// result: (I64Store [8] dst (I64Load [8] src mem) (I64Store dst (I64Load src mem) mem))
2924	for {
2925		if v.AuxInt != 16 {
2926			break
2927		}
2928		mem := v.Args[2]
2929		dst := v.Args[0]
2930		src := v.Args[1]
2931		v.reset(OpWasmI64Store)
2932		v.AuxInt = 8
2933		v.AddArg(dst)
2934		v0 := b.NewValue0(v.Pos, OpWasmI64Load, typ.UInt64)
2935		v0.AuxInt = 8
2936		v0.AddArg(src)
2937		v0.AddArg(mem)
2938		v.AddArg(v0)
2939		v1 := b.NewValue0(v.Pos, OpWasmI64Store, types.TypeMem)
2940		v1.AddArg(dst)
2941		v2 := b.NewValue0(v.Pos, OpWasmI64Load, typ.UInt64)
2942		v2.AddArg(src)
2943		v2.AddArg(mem)
2944		v1.AddArg(v2)
2945		v1.AddArg(mem)
2946		v.AddArg(v1)
2947		return true
2948	}
2949	// match: (Move [3] dst src mem)
2950	// result: (I64Store8 [2] dst (I64Load8U [2] src mem) (I64Store16 dst (I64Load16U src mem) mem))
2951	for {
2952		if v.AuxInt != 3 {
2953			break
2954		}
2955		mem := v.Args[2]
2956		dst := v.Args[0]
2957		src := v.Args[1]
2958		v.reset(OpWasmI64Store8)
2959		v.AuxInt = 2
2960		v.AddArg(dst)
2961		v0 := b.NewValue0(v.Pos, OpWasmI64Load8U, typ.UInt8)
2962		v0.AuxInt = 2
2963		v0.AddArg(src)
2964		v0.AddArg(mem)
2965		v.AddArg(v0)
2966		v1 := b.NewValue0(v.Pos, OpWasmI64Store16, types.TypeMem)
2967		v1.AddArg(dst)
2968		v2 := b.NewValue0(v.Pos, OpWasmI64Load16U, typ.UInt16)
2969		v2.AddArg(src)
2970		v2.AddArg(mem)
2971		v1.AddArg(v2)
2972		v1.AddArg(mem)
2973		v.AddArg(v1)
2974		return true
2975	}
2976	// match: (Move [5] dst src mem)
2977	// result: (I64Store8 [4] dst (I64Load8U [4] src mem) (I64Store32 dst (I64Load32U src mem) mem))
2978	for {
2979		if v.AuxInt != 5 {
2980			break
2981		}
2982		mem := v.Args[2]
2983		dst := v.Args[0]
2984		src := v.Args[1]
2985		v.reset(OpWasmI64Store8)
2986		v.AuxInt = 4
2987		v.AddArg(dst)
2988		v0 := b.NewValue0(v.Pos, OpWasmI64Load8U, typ.UInt8)
2989		v0.AuxInt = 4
2990		v0.AddArg(src)
2991		v0.AddArg(mem)
2992		v.AddArg(v0)
2993		v1 := b.NewValue0(v.Pos, OpWasmI64Store32, types.TypeMem)
2994		v1.AddArg(dst)
2995		v2 := b.NewValue0(v.Pos, OpWasmI64Load32U, typ.UInt32)
2996		v2.AddArg(src)
2997		v2.AddArg(mem)
2998		v1.AddArg(v2)
2999		v1.AddArg(mem)
3000		v.AddArg(v1)
3001		return true
3002	}
3003	// match: (Move [6] dst src mem)
3004	// result: (I64Store16 [4] dst (I64Load16U [4] src mem) (I64Store32 dst (I64Load32U src mem) mem))
3005	for {
3006		if v.AuxInt != 6 {
3007			break
3008		}
3009		mem := v.Args[2]
3010		dst := v.Args[0]
3011		src := v.Args[1]
3012		v.reset(OpWasmI64Store16)
3013		v.AuxInt = 4
3014		v.AddArg(dst)
3015		v0 := b.NewValue0(v.Pos, OpWasmI64Load16U, typ.UInt16)
3016		v0.AuxInt = 4
3017		v0.AddArg(src)
3018		v0.AddArg(mem)
3019		v.AddArg(v0)
3020		v1 := b.NewValue0(v.Pos, OpWasmI64Store32, types.TypeMem)
3021		v1.AddArg(dst)
3022		v2 := b.NewValue0(v.Pos, OpWasmI64Load32U, typ.UInt32)
3023		v2.AddArg(src)
3024		v2.AddArg(mem)
3025		v1.AddArg(v2)
3026		v1.AddArg(mem)
3027		v.AddArg(v1)
3028		return true
3029	}
3030	// match: (Move [7] dst src mem)
3031	// result: (I64Store32 [3] dst (I64Load32U [3] src mem) (I64Store32 dst (I64Load32U src mem) mem))
3032	for {
3033		if v.AuxInt != 7 {
3034			break
3035		}
3036		mem := v.Args[2]
3037		dst := v.Args[0]
3038		src := v.Args[1]
3039		v.reset(OpWasmI64Store32)
3040		v.AuxInt = 3
3041		v.AddArg(dst)
3042		v0 := b.NewValue0(v.Pos, OpWasmI64Load32U, typ.UInt32)
3043		v0.AuxInt = 3
3044		v0.AddArg(src)
3045		v0.AddArg(mem)
3046		v.AddArg(v0)
3047		v1 := b.NewValue0(v.Pos, OpWasmI64Store32, types.TypeMem)
3048		v1.AddArg(dst)
3049		v2 := b.NewValue0(v.Pos, OpWasmI64Load32U, typ.UInt32)
3050		v2.AddArg(src)
3051		v2.AddArg(mem)
3052		v1.AddArg(v2)
3053		v1.AddArg(mem)
3054		v.AddArg(v1)
3055		return true
3056	}
3057	return false
3058}
3059func rewriteValueWasm_OpMove_10(v *Value) bool {
3060	b := v.Block
3061	typ := &b.Func.Config.Types
3062	// match: (Move [s] dst src mem)
3063	// cond: s > 8 && s < 16
3064	// result: (I64Store [s-8] dst (I64Load [s-8] src mem) (I64Store dst (I64Load src mem) mem))
3065	for {
3066		s := v.AuxInt
3067		mem := v.Args[2]
3068		dst := v.Args[0]
3069		src := v.Args[1]
3070		if !(s > 8 && s < 16) {
3071			break
3072		}
3073		v.reset(OpWasmI64Store)
3074		v.AuxInt = s - 8
3075		v.AddArg(dst)
3076		v0 := b.NewValue0(v.Pos, OpWasmI64Load, typ.UInt64)
3077		v0.AuxInt = s - 8
3078		v0.AddArg(src)
3079		v0.AddArg(mem)
3080		v.AddArg(v0)
3081		v1 := b.NewValue0(v.Pos, OpWasmI64Store, types.TypeMem)
3082		v1.AddArg(dst)
3083		v2 := b.NewValue0(v.Pos, OpWasmI64Load, typ.UInt64)
3084		v2.AddArg(src)
3085		v2.AddArg(mem)
3086		v1.AddArg(v2)
3087		v1.AddArg(mem)
3088		v.AddArg(v1)
3089		return true
3090	}
3091	// match: (Move [s] dst src mem)
3092	// cond: s > 16 && s%16 != 0 && s%16 <= 8
3093	// result: (Move [s-s%16] (OffPtr <dst.Type> dst [s%16]) (OffPtr <src.Type> src [s%16]) (I64Store dst (I64Load src mem) mem))
3094	for {
3095		s := v.AuxInt
3096		mem := v.Args[2]
3097		dst := v.Args[0]
3098		src := v.Args[1]
3099		if !(s > 16 && s%16 != 0 && s%16 <= 8) {
3100			break
3101		}
3102		v.reset(OpMove)
3103		v.AuxInt = s - s%16
3104		v0 := b.NewValue0(v.Pos, OpOffPtr, dst.Type)
3105		v0.AuxInt = s % 16
3106		v0.AddArg(dst)
3107		v.AddArg(v0)
3108		v1 := b.NewValue0(v.Pos, OpOffPtr, src.Type)
3109		v1.AuxInt = s % 16
3110		v1.AddArg(src)
3111		v.AddArg(v1)
3112		v2 := b.NewValue0(v.Pos, OpWasmI64Store, types.TypeMem)
3113		v2.AddArg(dst)
3114		v3 := b.NewValue0(v.Pos, OpWasmI64Load, typ.UInt64)
3115		v3.AddArg(src)
3116		v3.AddArg(mem)
3117		v2.AddArg(v3)
3118		v2.AddArg(mem)
3119		v.AddArg(v2)
3120		return true
3121	}
3122	// match: (Move [s] dst src mem)
3123	// cond: s > 16 && s%16 != 0 && s%16 > 8
3124	// result: (Move [s-s%16] (OffPtr <dst.Type> dst [s%16]) (OffPtr <src.Type> src [s%16]) (I64Store [8] dst (I64Load [8] src mem) (I64Store dst (I64Load src mem) mem)))
3125	for {
3126		s := v.AuxInt
3127		mem := v.Args[2]
3128		dst := v.Args[0]
3129		src := v.Args[1]
3130		if !(s > 16 && s%16 != 0 && s%16 > 8) {
3131			break
3132		}
3133		v.reset(OpMove)
3134		v.AuxInt = s - s%16
3135		v0 := b.NewValue0(v.Pos, OpOffPtr, dst.Type)
3136		v0.AuxInt = s % 16
3137		v0.AddArg(dst)
3138		v.AddArg(v0)
3139		v1 := b.NewValue0(v.Pos, OpOffPtr, src.Type)
3140		v1.AuxInt = s % 16
3141		v1.AddArg(src)
3142		v.AddArg(v1)
3143		v2 := b.NewValue0(v.Pos, OpWasmI64Store, types.TypeMem)
3144		v2.AuxInt = 8
3145		v2.AddArg(dst)
3146		v3 := b.NewValue0(v.Pos, OpWasmI64Load, typ.UInt64)
3147		v3.AuxInt = 8
3148		v3.AddArg(src)
3149		v3.AddArg(mem)
3150		v2.AddArg(v3)
3151		v4 := b.NewValue0(v.Pos, OpWasmI64Store, types.TypeMem)
3152		v4.AddArg(dst)
3153		v5 := b.NewValue0(v.Pos, OpWasmI64Load, typ.UInt64)
3154		v5.AddArg(src)
3155		v5.AddArg(mem)
3156		v4.AddArg(v5)
3157		v4.AddArg(mem)
3158		v2.AddArg(v4)
3159		v.AddArg(v2)
3160		return true
3161	}
3162	// match: (Move [s] dst src mem)
3163	// cond: s%8 == 0
3164	// result: (LoweredMove [s/8] dst src mem)
3165	for {
3166		s := v.AuxInt
3167		mem := v.Args[2]
3168		dst := v.Args[0]
3169		src := v.Args[1]
3170		if !(s%8 == 0) {
3171			break
3172		}
3173		v.reset(OpWasmLoweredMove)
3174		v.AuxInt = s / 8
3175		v.AddArg(dst)
3176		v.AddArg(src)
3177		v.AddArg(mem)
3178		return true
3179	}
3180	return false
3181}
3182func rewriteValueWasm_OpMul16_0(v *Value) bool {
3183	// match: (Mul16 x y)
3184	// result: (I64Mul x y)
3185	for {
3186		y := v.Args[1]
3187		x := v.Args[0]
3188		v.reset(OpWasmI64Mul)
3189		v.AddArg(x)
3190		v.AddArg(y)
3191		return true
3192	}
3193}
3194func rewriteValueWasm_OpMul32_0(v *Value) bool {
3195	// match: (Mul32 x y)
3196	// result: (I64Mul x y)
3197	for {
3198		y := v.Args[1]
3199		x := v.Args[0]
3200		v.reset(OpWasmI64Mul)
3201		v.AddArg(x)
3202		v.AddArg(y)
3203		return true
3204	}
3205}
3206func rewriteValueWasm_OpMul32F_0(v *Value) bool {
3207	// match: (Mul32F x y)
3208	// result: (F32Mul x y)
3209	for {
3210		y := v.Args[1]
3211		x := v.Args[0]
3212		v.reset(OpWasmF32Mul)
3213		v.AddArg(x)
3214		v.AddArg(y)
3215		return true
3216	}
3217}
3218func rewriteValueWasm_OpMul64_0(v *Value) bool {
3219	// match: (Mul64 x y)
3220	// result: (I64Mul x y)
3221	for {
3222		y := v.Args[1]
3223		x := v.Args[0]
3224		v.reset(OpWasmI64Mul)
3225		v.AddArg(x)
3226		v.AddArg(y)
3227		return true
3228	}
3229}
3230func rewriteValueWasm_OpMul64F_0(v *Value) bool {
3231	// match: (Mul64F x y)
3232	// result: (F64Mul x y)
3233	for {
3234		y := v.Args[1]
3235		x := v.Args[0]
3236		v.reset(OpWasmF64Mul)
3237		v.AddArg(x)
3238		v.AddArg(y)
3239		return true
3240	}
3241}
3242func rewriteValueWasm_OpMul8_0(v *Value) bool {
3243	// match: (Mul8 x y)
3244	// result: (I64Mul x y)
3245	for {
3246		y := v.Args[1]
3247		x := v.Args[0]
3248		v.reset(OpWasmI64Mul)
3249		v.AddArg(x)
3250		v.AddArg(y)
3251		return true
3252	}
3253}
3254func rewriteValueWasm_OpNeg16_0(v *Value) bool {
3255	b := v.Block
3256	typ := &b.Func.Config.Types
3257	// match: (Neg16 x)
3258	// result: (I64Sub (I64Const [0]) x)
3259	for {
3260		x := v.Args[0]
3261		v.reset(OpWasmI64Sub)
3262		v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
3263		v0.AuxInt = 0
3264		v.AddArg(v0)
3265		v.AddArg(x)
3266		return true
3267	}
3268}
3269func rewriteValueWasm_OpNeg32_0(v *Value) bool {
3270	b := v.Block
3271	typ := &b.Func.Config.Types
3272	// match: (Neg32 x)
3273	// result: (I64Sub (I64Const [0]) x)
3274	for {
3275		x := v.Args[0]
3276		v.reset(OpWasmI64Sub)
3277		v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
3278		v0.AuxInt = 0
3279		v.AddArg(v0)
3280		v.AddArg(x)
3281		return true
3282	}
3283}
3284func rewriteValueWasm_OpNeg32F_0(v *Value) bool {
3285	// match: (Neg32F x)
3286	// result: (F32Neg x)
3287	for {
3288		x := v.Args[0]
3289		v.reset(OpWasmF32Neg)
3290		v.AddArg(x)
3291		return true
3292	}
3293}
3294func rewriteValueWasm_OpNeg64_0(v *Value) bool {
3295	b := v.Block
3296	typ := &b.Func.Config.Types
3297	// match: (Neg64 x)
3298	// result: (I64Sub (I64Const [0]) x)
3299	for {
3300		x := v.Args[0]
3301		v.reset(OpWasmI64Sub)
3302		v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
3303		v0.AuxInt = 0
3304		v.AddArg(v0)
3305		v.AddArg(x)
3306		return true
3307	}
3308}
3309func rewriteValueWasm_OpNeg64F_0(v *Value) bool {
3310	// match: (Neg64F x)
3311	// result: (F64Neg x)
3312	for {
3313		x := v.Args[0]
3314		v.reset(OpWasmF64Neg)
3315		v.AddArg(x)
3316		return true
3317	}
3318}
3319func rewriteValueWasm_OpNeg8_0(v *Value) bool {
3320	b := v.Block
3321	typ := &b.Func.Config.Types
3322	// match: (Neg8 x)
3323	// result: (I64Sub (I64Const [0]) x)
3324	for {
3325		x := v.Args[0]
3326		v.reset(OpWasmI64Sub)
3327		v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
3328		v0.AuxInt = 0
3329		v.AddArg(v0)
3330		v.AddArg(x)
3331		return true
3332	}
3333}
3334func rewriteValueWasm_OpNeq16_0(v *Value) bool {
3335	b := v.Block
3336	typ := &b.Func.Config.Types
3337	// match: (Neq16 x y)
3338	// result: (I64Ne (ZeroExt16to64 x) (ZeroExt16to64 y))
3339	for {
3340		y := v.Args[1]
3341		x := v.Args[0]
3342		v.reset(OpWasmI64Ne)
3343		v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
3344		v0.AddArg(x)
3345		v.AddArg(v0)
3346		v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
3347		v1.AddArg(y)
3348		v.AddArg(v1)
3349		return true
3350	}
3351}
3352func rewriteValueWasm_OpNeq32_0(v *Value) bool {
3353	b := v.Block
3354	typ := &b.Func.Config.Types
3355	// match: (Neq32 x y)
3356	// result: (I64Ne (ZeroExt32to64 x) (ZeroExt32to64 y))
3357	for {
3358		y := v.Args[1]
3359		x := v.Args[0]
3360		v.reset(OpWasmI64Ne)
3361		v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
3362		v0.AddArg(x)
3363		v.AddArg(v0)
3364		v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
3365		v1.AddArg(y)
3366		v.AddArg(v1)
3367		return true
3368	}
3369}
3370func rewriteValueWasm_OpNeq32F_0(v *Value) bool {
3371	// match: (Neq32F x y)
3372	// result: (F32Ne x y)
3373	for {
3374		y := v.Args[1]
3375		x := v.Args[0]
3376		v.reset(OpWasmF32Ne)
3377		v.AddArg(x)
3378		v.AddArg(y)
3379		return true
3380	}
3381}
3382func rewriteValueWasm_OpNeq64_0(v *Value) bool {
3383	// match: (Neq64 x y)
3384	// result: (I64Ne x y)
3385	for {
3386		y := v.Args[1]
3387		x := v.Args[0]
3388		v.reset(OpWasmI64Ne)
3389		v.AddArg(x)
3390		v.AddArg(y)
3391		return true
3392	}
3393}
3394func rewriteValueWasm_OpNeq64F_0(v *Value) bool {
3395	// match: (Neq64F x y)
3396	// result: (F64Ne x y)
3397	for {
3398		y := v.Args[1]
3399		x := v.Args[0]
3400		v.reset(OpWasmF64Ne)
3401		v.AddArg(x)
3402		v.AddArg(y)
3403		return true
3404	}
3405}
3406func rewriteValueWasm_OpNeq8_0(v *Value) bool {
3407	b := v.Block
3408	typ := &b.Func.Config.Types
3409	// match: (Neq8 x y)
3410	// result: (I64Ne (ZeroExt8to64 x) (ZeroExt8to64 y))
3411	for {
3412		y := v.Args[1]
3413		x := v.Args[0]
3414		v.reset(OpWasmI64Ne)
3415		v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
3416		v0.AddArg(x)
3417		v.AddArg(v0)
3418		v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
3419		v1.AddArg(y)
3420		v.AddArg(v1)
3421		return true
3422	}
3423}
3424func rewriteValueWasm_OpNeqB_0(v *Value) bool {
3425	// match: (NeqB x y)
3426	// result: (I64Ne x y)
3427	for {
3428		y := v.Args[1]
3429		x := v.Args[0]
3430		v.reset(OpWasmI64Ne)
3431		v.AddArg(x)
3432		v.AddArg(y)
3433		return true
3434	}
3435}
3436func rewriteValueWasm_OpNeqPtr_0(v *Value) bool {
3437	// match: (NeqPtr x y)
3438	// result: (I64Ne x y)
3439	for {
3440		y := v.Args[1]
3441		x := v.Args[0]
3442		v.reset(OpWasmI64Ne)
3443		v.AddArg(x)
3444		v.AddArg(y)
3445		return true
3446	}
3447}
3448func rewriteValueWasm_OpNilCheck_0(v *Value) bool {
3449	// match: (NilCheck ptr mem)
3450	// result: (LoweredNilCheck ptr mem)
3451	for {
3452		mem := v.Args[1]
3453		ptr := v.Args[0]
3454		v.reset(OpWasmLoweredNilCheck)
3455		v.AddArg(ptr)
3456		v.AddArg(mem)
3457		return true
3458	}
3459}
3460func rewriteValueWasm_OpNot_0(v *Value) bool {
3461	// match: (Not x)
3462	// result: (I64Eqz x)
3463	for {
3464		x := v.Args[0]
3465		v.reset(OpWasmI64Eqz)
3466		v.AddArg(x)
3467		return true
3468	}
3469}
3470func rewriteValueWasm_OpOffPtr_0(v *Value) bool {
3471	// match: (OffPtr [off] ptr)
3472	// result: (I64AddConst [off] ptr)
3473	for {
3474		off := v.AuxInt
3475		ptr := v.Args[0]
3476		v.reset(OpWasmI64AddConst)
3477		v.AuxInt = off
3478		v.AddArg(ptr)
3479		return true
3480	}
3481}
3482func rewriteValueWasm_OpOr16_0(v *Value) bool {
3483	// match: (Or16 x y)
3484	// result: (I64Or x y)
3485	for {
3486		y := v.Args[1]
3487		x := v.Args[0]
3488		v.reset(OpWasmI64Or)
3489		v.AddArg(x)
3490		v.AddArg(y)
3491		return true
3492	}
3493}
3494func rewriteValueWasm_OpOr32_0(v *Value) bool {
3495	// match: (Or32 x y)
3496	// result: (I64Or x y)
3497	for {
3498		y := v.Args[1]
3499		x := v.Args[0]
3500		v.reset(OpWasmI64Or)
3501		v.AddArg(x)
3502		v.AddArg(y)
3503		return true
3504	}
3505}
3506func rewriteValueWasm_OpOr64_0(v *Value) bool {
3507	// match: (Or64 x y)
3508	// result: (I64Or x y)
3509	for {
3510		y := v.Args[1]
3511		x := v.Args[0]
3512		v.reset(OpWasmI64Or)
3513		v.AddArg(x)
3514		v.AddArg(y)
3515		return true
3516	}
3517}
3518func rewriteValueWasm_OpOr8_0(v *Value) bool {
3519	// match: (Or8 x y)
3520	// result: (I64Or x y)
3521	for {
3522		y := v.Args[1]
3523		x := v.Args[0]
3524		v.reset(OpWasmI64Or)
3525		v.AddArg(x)
3526		v.AddArg(y)
3527		return true
3528	}
3529}
3530func rewriteValueWasm_OpOrB_0(v *Value) bool {
3531	// match: (OrB x y)
3532	// result: (I64Or x y)
3533	for {
3534		y := v.Args[1]
3535		x := v.Args[0]
3536		v.reset(OpWasmI64Or)
3537		v.AddArg(x)
3538		v.AddArg(y)
3539		return true
3540	}
3541}
3542func rewriteValueWasm_OpPopCount16_0(v *Value) bool {
3543	b := v.Block
3544	typ := &b.Func.Config.Types
3545	// match: (PopCount16 x)
3546	// result: (I64Popcnt (ZeroExt16to64 x))
3547	for {
3548		x := v.Args[0]
3549		v.reset(OpWasmI64Popcnt)
3550		v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
3551		v0.AddArg(x)
3552		v.AddArg(v0)
3553		return true
3554	}
3555}
3556func rewriteValueWasm_OpPopCount32_0(v *Value) bool {
3557	b := v.Block
3558	typ := &b.Func.Config.Types
3559	// match: (PopCount32 x)
3560	// result: (I64Popcnt (ZeroExt32to64 x))
3561	for {
3562		x := v.Args[0]
3563		v.reset(OpWasmI64Popcnt)
3564		v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
3565		v0.AddArg(x)
3566		v.AddArg(v0)
3567		return true
3568	}
3569}
3570func rewriteValueWasm_OpPopCount64_0(v *Value) bool {
3571	// match: (PopCount64 x)
3572	// result: (I64Popcnt x)
3573	for {
3574		x := v.Args[0]
3575		v.reset(OpWasmI64Popcnt)
3576		v.AddArg(x)
3577		return true
3578	}
3579}
3580func rewriteValueWasm_OpPopCount8_0(v *Value) bool {
3581	b := v.Block
3582	typ := &b.Func.Config.Types
3583	// match: (PopCount8 x)
3584	// result: (I64Popcnt (ZeroExt8to64 x))
3585	for {
3586		x := v.Args[0]
3587		v.reset(OpWasmI64Popcnt)
3588		v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
3589		v0.AddArg(x)
3590		v.AddArg(v0)
3591		return true
3592	}
3593}
3594func rewriteValueWasm_OpRotateLeft16_0(v *Value) bool {
3595	b := v.Block
3596	typ := &b.Func.Config.Types
3597	// match: (RotateLeft16 <t> x (I64Const [c]))
3598	// result: (Or16 (Lsh16x64 <t> x (I64Const [c&15])) (Rsh16Ux64 <t> x (I64Const [-c&15])))
3599	for {
3600		t := v.Type
3601		_ = v.Args[1]
3602		x := v.Args[0]
3603		v_1 := v.Args[1]
3604		if v_1.Op != OpWasmI64Const {
3605			break
3606		}
3607		c := v_1.AuxInt
3608		v.reset(OpOr16)
3609		v0 := b.NewValue0(v.Pos, OpLsh16x64, t)
3610		v0.AddArg(x)
3611		v1 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
3612		v1.AuxInt = c & 15
3613		v0.AddArg(v1)
3614		v.AddArg(v0)
3615		v2 := b.NewValue0(v.Pos, OpRsh16Ux64, t)
3616		v2.AddArg(x)
3617		v3 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
3618		v3.AuxInt = -c & 15
3619		v2.AddArg(v3)
3620		v.AddArg(v2)
3621		return true
3622	}
3623	return false
3624}
3625func rewriteValueWasm_OpRotateLeft32_0(v *Value) bool {
3626	// match: (RotateLeft32 x y)
3627	// result: (I32Rotl x y)
3628	for {
3629		y := v.Args[1]
3630		x := v.Args[0]
3631		v.reset(OpWasmI32Rotl)
3632		v.AddArg(x)
3633		v.AddArg(y)
3634		return true
3635	}
3636}
3637func rewriteValueWasm_OpRotateLeft64_0(v *Value) bool {
3638	// match: (RotateLeft64 x y)
3639	// result: (I64Rotl x y)
3640	for {
3641		y := v.Args[1]
3642		x := v.Args[0]
3643		v.reset(OpWasmI64Rotl)
3644		v.AddArg(x)
3645		v.AddArg(y)
3646		return true
3647	}
3648}
3649func rewriteValueWasm_OpRotateLeft8_0(v *Value) bool {
3650	b := v.Block
3651	typ := &b.Func.Config.Types
3652	// match: (RotateLeft8 <t> x (I64Const [c]))
3653	// result: (Or8 (Lsh8x64 <t> x (I64Const [c&7])) (Rsh8Ux64 <t> x (I64Const [-c&7])))
3654	for {
3655		t := v.Type
3656		_ = v.Args[1]
3657		x := v.Args[0]
3658		v_1 := v.Args[1]
3659		if v_1.Op != OpWasmI64Const {
3660			break
3661		}
3662		c := v_1.AuxInt
3663		v.reset(OpOr8)
3664		v0 := b.NewValue0(v.Pos, OpLsh8x64, t)
3665		v0.AddArg(x)
3666		v1 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
3667		v1.AuxInt = c & 7
3668		v0.AddArg(v1)
3669		v.AddArg(v0)
3670		v2 := b.NewValue0(v.Pos, OpRsh8Ux64, t)
3671		v2.AddArg(x)
3672		v3 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
3673		v3.AuxInt = -c & 7
3674		v2.AddArg(v3)
3675		v.AddArg(v2)
3676		return true
3677	}
3678	return false
3679}
3680func rewriteValueWasm_OpRound32F_0(v *Value) bool {
3681	// match: (Round32F x)
3682	// result: x
3683	for {
3684		x := v.Args[0]
3685		v.reset(OpCopy)
3686		v.Type = x.Type
3687		v.AddArg(x)
3688		return true
3689	}
3690}
3691func rewriteValueWasm_OpRound64F_0(v *Value) bool {
3692	// match: (Round64F x)
3693	// result: x
3694	for {
3695		x := v.Args[0]
3696		v.reset(OpCopy)
3697		v.Type = x.Type
3698		v.AddArg(x)
3699		return true
3700	}
3701}
3702func rewriteValueWasm_OpRoundToEven_0(v *Value) bool {
3703	// match: (RoundToEven x)
3704	// result: (F64Nearest x)
3705	for {
3706		x := v.Args[0]
3707		v.reset(OpWasmF64Nearest)
3708		v.AddArg(x)
3709		return true
3710	}
3711}
3712func rewriteValueWasm_OpRsh16Ux16_0(v *Value) bool {
3713	b := v.Block
3714	typ := &b.Func.Config.Types
3715	// match: (Rsh16Ux16 x y)
3716	// result: (Rsh64Ux64 (ZeroExt16to64 x) (ZeroExt16to64 y))
3717	for {
3718		y := v.Args[1]
3719		x := v.Args[0]
3720		v.reset(OpRsh64Ux64)
3721		v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
3722		v0.AddArg(x)
3723		v.AddArg(v0)
3724		v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
3725		v1.AddArg(y)
3726		v.AddArg(v1)
3727		return true
3728	}
3729}
3730func rewriteValueWasm_OpRsh16Ux32_0(v *Value) bool {
3731	b := v.Block
3732	typ := &b.Func.Config.Types
3733	// match: (Rsh16Ux32 x y)
3734	// result: (Rsh64Ux64 (ZeroExt16to64 x) (ZeroExt32to64 y))
3735	for {
3736		y := v.Args[1]
3737		x := v.Args[0]
3738		v.reset(OpRsh64Ux64)
3739		v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
3740		v0.AddArg(x)
3741		v.AddArg(v0)
3742		v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
3743		v1.AddArg(y)
3744		v.AddArg(v1)
3745		return true
3746	}
3747}
3748func rewriteValueWasm_OpRsh16Ux64_0(v *Value) bool {
3749	b := v.Block
3750	typ := &b.Func.Config.Types
3751	// match: (Rsh16Ux64 x y)
3752	// result: (Rsh64Ux64 (ZeroExt16to64 x) y)
3753	for {
3754		y := v.Args[1]
3755		x := v.Args[0]
3756		v.reset(OpRsh64Ux64)
3757		v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
3758		v0.AddArg(x)
3759		v.AddArg(v0)
3760		v.AddArg(y)
3761		return true
3762	}
3763}
3764func rewriteValueWasm_OpRsh16Ux8_0(v *Value) bool {
3765	b := v.Block
3766	typ := &b.Func.Config.Types
3767	// match: (Rsh16Ux8 x y)
3768	// result: (Rsh64Ux64 (ZeroExt16to64 x) (ZeroExt8to64 y))
3769	for {
3770		y := v.Args[1]
3771		x := v.Args[0]
3772		v.reset(OpRsh64Ux64)
3773		v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
3774		v0.AddArg(x)
3775		v.AddArg(v0)
3776		v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
3777		v1.AddArg(y)
3778		v.AddArg(v1)
3779		return true
3780	}
3781}
3782func rewriteValueWasm_OpRsh16x16_0(v *Value) bool {
3783	b := v.Block
3784	typ := &b.Func.Config.Types
3785	// match: (Rsh16x16 x y)
3786	// result: (Rsh64x64 (SignExt16to64 x) (ZeroExt16to64 y))
3787	for {
3788		y := v.Args[1]
3789		x := v.Args[0]
3790		v.reset(OpRsh64x64)
3791		v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
3792		v0.AddArg(x)
3793		v.AddArg(v0)
3794		v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
3795		v1.AddArg(y)
3796		v.AddArg(v1)
3797		return true
3798	}
3799}
3800func rewriteValueWasm_OpRsh16x32_0(v *Value) bool {
3801	b := v.Block
3802	typ := &b.Func.Config.Types
3803	// match: (Rsh16x32 x y)
3804	// result: (Rsh64x64 (SignExt16to64 x) (ZeroExt32to64 y))
3805	for {
3806		y := v.Args[1]
3807		x := v.Args[0]
3808		v.reset(OpRsh64x64)
3809		v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
3810		v0.AddArg(x)
3811		v.AddArg(v0)
3812		v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
3813		v1.AddArg(y)
3814		v.AddArg(v1)
3815		return true
3816	}
3817}
3818func rewriteValueWasm_OpRsh16x64_0(v *Value) bool {
3819	b := v.Block
3820	typ := &b.Func.Config.Types
3821	// match: (Rsh16x64 x y)
3822	// result: (Rsh64x64 (SignExt16to64 x) y)
3823	for {
3824		y := v.Args[1]
3825		x := v.Args[0]
3826		v.reset(OpRsh64x64)
3827		v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
3828		v0.AddArg(x)
3829		v.AddArg(v0)
3830		v.AddArg(y)
3831		return true
3832	}
3833}
3834func rewriteValueWasm_OpRsh16x8_0(v *Value) bool {
3835	b := v.Block
3836	typ := &b.Func.Config.Types
3837	// match: (Rsh16x8 x y)
3838	// result: (Rsh64x64 (SignExt16to64 x) (ZeroExt8to64 y))
3839	for {
3840		y := v.Args[1]
3841		x := v.Args[0]
3842		v.reset(OpRsh64x64)
3843		v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
3844		v0.AddArg(x)
3845		v.AddArg(v0)
3846		v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
3847		v1.AddArg(y)
3848		v.AddArg(v1)
3849		return true
3850	}
3851}
3852func rewriteValueWasm_OpRsh32Ux16_0(v *Value) bool {
3853	b := v.Block
3854	typ := &b.Func.Config.Types
3855	// match: (Rsh32Ux16 x y)
3856	// result: (Rsh64Ux64 (ZeroExt32to64 x) (ZeroExt16to64 y))
3857	for {
3858		y := v.Args[1]
3859		x := v.Args[0]
3860		v.reset(OpRsh64Ux64)
3861		v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
3862		v0.AddArg(x)
3863		v.AddArg(v0)
3864		v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
3865		v1.AddArg(y)
3866		v.AddArg(v1)
3867		return true
3868	}
3869}
3870func rewriteValueWasm_OpRsh32Ux32_0(v *Value) bool {
3871	b := v.Block
3872	typ := &b.Func.Config.Types
3873	// match: (Rsh32Ux32 x y)
3874	// result: (Rsh64Ux64 (ZeroExt32to64 x) (ZeroExt32to64 y))
3875	for {
3876		y := v.Args[1]
3877		x := v.Args[0]
3878		v.reset(OpRsh64Ux64)
3879		v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
3880		v0.AddArg(x)
3881		v.AddArg(v0)
3882		v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
3883		v1.AddArg(y)
3884		v.AddArg(v1)
3885		return true
3886	}
3887}
3888func rewriteValueWasm_OpRsh32Ux64_0(v *Value) bool {
3889	b := v.Block
3890	typ := &b.Func.Config.Types
3891	// match: (Rsh32Ux64 x y)
3892	// result: (Rsh64Ux64 (ZeroExt32to64 x) y)
3893	for {
3894		y := v.Args[1]
3895		x := v.Args[0]
3896		v.reset(OpRsh64Ux64)
3897		v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
3898		v0.AddArg(x)
3899		v.AddArg(v0)
3900		v.AddArg(y)
3901		return true
3902	}
3903}
3904func rewriteValueWasm_OpRsh32Ux8_0(v *Value) bool {
3905	b := v.Block
3906	typ := &b.Func.Config.Types
3907	// match: (Rsh32Ux8 x y)
3908	// result: (Rsh64Ux64 (ZeroExt32to64 x) (ZeroExt8to64 y))
3909	for {
3910		y := v.Args[1]
3911		x := v.Args[0]
3912		v.reset(OpRsh64Ux64)
3913		v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
3914		v0.AddArg(x)
3915		v.AddArg(v0)
3916		v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
3917		v1.AddArg(y)
3918		v.AddArg(v1)
3919		return true
3920	}
3921}
3922func rewriteValueWasm_OpRsh32x16_0(v *Value) bool {
3923	b := v.Block
3924	typ := &b.Func.Config.Types
3925	// match: (Rsh32x16 x y)
3926	// result: (Rsh64x64 (SignExt32to64 x) (ZeroExt16to64 y))
3927	for {
3928		y := v.Args[1]
3929		x := v.Args[0]
3930		v.reset(OpRsh64x64)
3931		v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
3932		v0.AddArg(x)
3933		v.AddArg(v0)
3934		v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
3935		v1.AddArg(y)
3936		v.AddArg(v1)
3937		return true
3938	}
3939}
3940func rewriteValueWasm_OpRsh32x32_0(v *Value) bool {
3941	b := v.Block
3942	typ := &b.Func.Config.Types
3943	// match: (Rsh32x32 x y)
3944	// result: (Rsh64x64 (SignExt32to64 x) (ZeroExt32to64 y))
3945	for {
3946		y := v.Args[1]
3947		x := v.Args[0]
3948		v.reset(OpRsh64x64)
3949		v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
3950		v0.AddArg(x)
3951		v.AddArg(v0)
3952		v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
3953		v1.AddArg(y)
3954		v.AddArg(v1)
3955		return true
3956	}
3957}
3958func rewriteValueWasm_OpRsh32x64_0(v *Value) bool {
3959	b := v.Block
3960	typ := &b.Func.Config.Types
3961	// match: (Rsh32x64 x y)
3962	// result: (Rsh64x64 (SignExt32to64 x) y)
3963	for {
3964		y := v.Args[1]
3965		x := v.Args[0]
3966		v.reset(OpRsh64x64)
3967		v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
3968		v0.AddArg(x)
3969		v.AddArg(v0)
3970		v.AddArg(y)
3971		return true
3972	}
3973}
3974func rewriteValueWasm_OpRsh32x8_0(v *Value) bool {
3975	b := v.Block
3976	typ := &b.Func.Config.Types
3977	// match: (Rsh32x8 x y)
3978	// result: (Rsh64x64 (SignExt32to64 x) (ZeroExt8to64 y))
3979	for {
3980		y := v.Args[1]
3981		x := v.Args[0]
3982		v.reset(OpRsh64x64)
3983		v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
3984		v0.AddArg(x)
3985		v.AddArg(v0)
3986		v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
3987		v1.AddArg(y)
3988		v.AddArg(v1)
3989		return true
3990	}
3991}
3992func rewriteValueWasm_OpRsh64Ux16_0(v *Value) bool {
3993	b := v.Block
3994	typ := &b.Func.Config.Types
3995	// match: (Rsh64Ux16 x y)
3996	// result: (Rsh64Ux64 x (ZeroExt16to64 y))
3997	for {
3998		y := v.Args[1]
3999		x := v.Args[0]
4000		v.reset(OpRsh64Ux64)
4001		v.AddArg(x)
4002		v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
4003		v0.AddArg(y)
4004		v.AddArg(v0)
4005		return true
4006	}
4007}
4008func rewriteValueWasm_OpRsh64Ux32_0(v *Value) bool {
4009	b := v.Block
4010	typ := &b.Func.Config.Types
4011	// match: (Rsh64Ux32 x y)
4012	// result: (Rsh64Ux64 x (ZeroExt32to64 y))
4013	for {
4014		y := v.Args[1]
4015		x := v.Args[0]
4016		v.reset(OpRsh64Ux64)
4017		v.AddArg(x)
4018		v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
4019		v0.AddArg(y)
4020		v.AddArg(v0)
4021		return true
4022	}
4023}
4024func rewriteValueWasm_OpRsh64Ux64_0(v *Value) bool {
4025	b := v.Block
4026	typ := &b.Func.Config.Types
4027	// match: (Rsh64Ux64 x y)
4028	// cond: shiftIsBounded(v)
4029	// result: (I64ShrU x y)
4030	for {
4031		y := v.Args[1]
4032		x := v.Args[0]
4033		if !(shiftIsBounded(v)) {
4034			break
4035		}
4036		v.reset(OpWasmI64ShrU)
4037		v.AddArg(x)
4038		v.AddArg(y)
4039		return true
4040	}
4041	// match: (Rsh64Ux64 x (I64Const [c]))
4042	// cond: uint64(c) < 64
4043	// result: (I64ShrU x (I64Const [c]))
4044	for {
4045		_ = v.Args[1]
4046		x := v.Args[0]
4047		v_1 := v.Args[1]
4048		if v_1.Op != OpWasmI64Const {
4049			break
4050		}
4051		c := v_1.AuxInt
4052		if !(uint64(c) < 64) {
4053			break
4054		}
4055		v.reset(OpWasmI64ShrU)
4056		v.AddArg(x)
4057		v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
4058		v0.AuxInt = c
4059		v.AddArg(v0)
4060		return true
4061	}
4062	// match: (Rsh64Ux64 x (I64Const [c]))
4063	// cond: uint64(c) >= 64
4064	// result: (I64Const [0])
4065	for {
4066		_ = v.Args[1]
4067		v_1 := v.Args[1]
4068		if v_1.Op != OpWasmI64Const {
4069			break
4070		}
4071		c := v_1.AuxInt
4072		if !(uint64(c) >= 64) {
4073			break
4074		}
4075		v.reset(OpWasmI64Const)
4076		v.AuxInt = 0
4077		return true
4078	}
4079	// match: (Rsh64Ux64 x y)
4080	// result: (Select (I64ShrU x y) (I64Const [0]) (I64LtU y (I64Const [64])))
4081	for {
4082		y := v.Args[1]
4083		x := v.Args[0]
4084		v.reset(OpWasmSelect)
4085		v0 := b.NewValue0(v.Pos, OpWasmI64ShrU, typ.Int64)
4086		v0.AddArg(x)
4087		v0.AddArg(y)
4088		v.AddArg(v0)
4089		v1 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
4090		v1.AuxInt = 0
4091		v.AddArg(v1)
4092		v2 := b.NewValue0(v.Pos, OpWasmI64LtU, typ.Bool)
4093		v2.AddArg(y)
4094		v3 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
4095		v3.AuxInt = 64
4096		v2.AddArg(v3)
4097		v.AddArg(v2)
4098		return true
4099	}
4100}
4101func rewriteValueWasm_OpRsh64Ux8_0(v *Value) bool {
4102	b := v.Block
4103	typ := &b.Func.Config.Types
4104	// match: (Rsh64Ux8 x y)
4105	// result: (Rsh64Ux64 x (ZeroExt8to64 y))
4106	for {
4107		y := v.Args[1]
4108		x := v.Args[0]
4109		v.reset(OpRsh64Ux64)
4110		v.AddArg(x)
4111		v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
4112		v0.AddArg(y)
4113		v.AddArg(v0)
4114		return true
4115	}
4116}
4117func rewriteValueWasm_OpRsh64x16_0(v *Value) bool {
4118	b := v.Block
4119	typ := &b.Func.Config.Types
4120	// match: (Rsh64x16 x y)
4121	// result: (Rsh64x64 x (ZeroExt16to64 y))
4122	for {
4123		y := v.Args[1]
4124		x := v.Args[0]
4125		v.reset(OpRsh64x64)
4126		v.AddArg(x)
4127		v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
4128		v0.AddArg(y)
4129		v.AddArg(v0)
4130		return true
4131	}
4132}
4133func rewriteValueWasm_OpRsh64x32_0(v *Value) bool {
4134	b := v.Block
4135	typ := &b.Func.Config.Types
4136	// match: (Rsh64x32 x y)
4137	// result: (Rsh64x64 x (ZeroExt32to64 y))
4138	for {
4139		y := v.Args[1]
4140		x := v.Args[0]
4141		v.reset(OpRsh64x64)
4142		v.AddArg(x)
4143		v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
4144		v0.AddArg(y)
4145		v.AddArg(v0)
4146		return true
4147	}
4148}
4149func rewriteValueWasm_OpRsh64x64_0(v *Value) bool {
4150	b := v.Block
4151	typ := &b.Func.Config.Types
4152	// match: (Rsh64x64 x y)
4153	// cond: shiftIsBounded(v)
4154	// result: (I64ShrS x y)
4155	for {
4156		y := v.Args[1]
4157		x := v.Args[0]
4158		if !(shiftIsBounded(v)) {
4159			break
4160		}
4161		v.reset(OpWasmI64ShrS)
4162		v.AddArg(x)
4163		v.AddArg(y)
4164		return true
4165	}
4166	// match: (Rsh64x64 x (I64Const [c]))
4167	// cond: uint64(c) < 64
4168	// result: (I64ShrS x (I64Const [c]))
4169	for {
4170		_ = v.Args[1]
4171		x := v.Args[0]
4172		v_1 := v.Args[1]
4173		if v_1.Op != OpWasmI64Const {
4174			break
4175		}
4176		c := v_1.AuxInt
4177		if !(uint64(c) < 64) {
4178			break
4179		}
4180		v.reset(OpWasmI64ShrS)
4181		v.AddArg(x)
4182		v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
4183		v0.AuxInt = c
4184		v.AddArg(v0)
4185		return true
4186	}
4187	// match: (Rsh64x64 x (I64Const [c]))
4188	// cond: uint64(c) >= 64
4189	// result: (I64ShrS x (I64Const [63]))
4190	for {
4191		_ = v.Args[1]
4192		x := v.Args[0]
4193		v_1 := v.Args[1]
4194		if v_1.Op != OpWasmI64Const {
4195			break
4196		}
4197		c := v_1.AuxInt
4198		if !(uint64(c) >= 64) {
4199			break
4200		}
4201		v.reset(OpWasmI64ShrS)
4202		v.AddArg(x)
4203		v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
4204		v0.AuxInt = 63
4205		v.AddArg(v0)
4206		return true
4207	}
4208	// match: (Rsh64x64 x y)
4209	// result: (I64ShrS x (Select <typ.Int64> y (I64Const [63]) (I64LtU y (I64Const [64]))))
4210	for {
4211		y := v.Args[1]
4212		x := v.Args[0]
4213		v.reset(OpWasmI64ShrS)
4214		v.AddArg(x)
4215		v0 := b.NewValue0(v.Pos, OpWasmSelect, typ.Int64)
4216		v0.AddArg(y)
4217		v1 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
4218		v1.AuxInt = 63
4219		v0.AddArg(v1)
4220		v2 := b.NewValue0(v.Pos, OpWasmI64LtU, typ.Bool)
4221		v2.AddArg(y)
4222		v3 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
4223		v3.AuxInt = 64
4224		v2.AddArg(v3)
4225		v0.AddArg(v2)
4226		v.AddArg(v0)
4227		return true
4228	}
4229}
4230func rewriteValueWasm_OpRsh64x8_0(v *Value) bool {
4231	b := v.Block
4232	typ := &b.Func.Config.Types
4233	// match: (Rsh64x8 x y)
4234	// result: (Rsh64x64 x (ZeroExt8to64 y))
4235	for {
4236		y := v.Args[1]
4237		x := v.Args[0]
4238		v.reset(OpRsh64x64)
4239		v.AddArg(x)
4240		v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
4241		v0.AddArg(y)
4242		v.AddArg(v0)
4243		return true
4244	}
4245}
4246func rewriteValueWasm_OpRsh8Ux16_0(v *Value) bool {
4247	b := v.Block
4248	typ := &b.Func.Config.Types
4249	// match: (Rsh8Ux16 x y)
4250	// result: (Rsh64Ux64 (ZeroExt8to64 x) (ZeroExt16to64 y))
4251	for {
4252		y := v.Args[1]
4253		x := v.Args[0]
4254		v.reset(OpRsh64Ux64)
4255		v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
4256		v0.AddArg(x)
4257		v.AddArg(v0)
4258		v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
4259		v1.AddArg(y)
4260		v.AddArg(v1)
4261		return true
4262	}
4263}
4264func rewriteValueWasm_OpRsh8Ux32_0(v *Value) bool {
4265	b := v.Block
4266	typ := &b.Func.Config.Types
4267	// match: (Rsh8Ux32 x y)
4268	// result: (Rsh64Ux64 (ZeroExt8to64 x) (ZeroExt32to64 y))
4269	for {
4270		y := v.Args[1]
4271		x := v.Args[0]
4272		v.reset(OpRsh64Ux64)
4273		v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
4274		v0.AddArg(x)
4275		v.AddArg(v0)
4276		v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
4277		v1.AddArg(y)
4278		v.AddArg(v1)
4279		return true
4280	}
4281}
4282func rewriteValueWasm_OpRsh8Ux64_0(v *Value) bool {
4283	b := v.Block
4284	typ := &b.Func.Config.Types
4285	// match: (Rsh8Ux64 x y)
4286	// result: (Rsh64Ux64 (ZeroExt8to64 x) y)
4287	for {
4288		y := v.Args[1]
4289		x := v.Args[0]
4290		v.reset(OpRsh64Ux64)
4291		v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
4292		v0.AddArg(x)
4293		v.AddArg(v0)
4294		v.AddArg(y)
4295		return true
4296	}
4297}
4298func rewriteValueWasm_OpRsh8Ux8_0(v *Value) bool {
4299	b := v.Block
4300	typ := &b.Func.Config.Types
4301	// match: (Rsh8Ux8 x y)
4302	// result: (Rsh64Ux64 (ZeroExt8to64 x) (ZeroExt8to64 y))
4303	for {
4304		y := v.Args[1]
4305		x := v.Args[0]
4306		v.reset(OpRsh64Ux64)
4307		v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
4308		v0.AddArg(x)
4309		v.AddArg(v0)
4310		v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
4311		v1.AddArg(y)
4312		v.AddArg(v1)
4313		return true
4314	}
4315}
4316func rewriteValueWasm_OpRsh8x16_0(v *Value) bool {
4317	b := v.Block
4318	typ := &b.Func.Config.Types
4319	// match: (Rsh8x16 x y)
4320	// result: (Rsh64x64 (SignExt8to64 x) (ZeroExt16to64 y))
4321	for {
4322		y := v.Args[1]
4323		x := v.Args[0]
4324		v.reset(OpRsh64x64)
4325		v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
4326		v0.AddArg(x)
4327		v.AddArg(v0)
4328		v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
4329		v1.AddArg(y)
4330		v.AddArg(v1)
4331		return true
4332	}
4333}
4334func rewriteValueWasm_OpRsh8x32_0(v *Value) bool {
4335	b := v.Block
4336	typ := &b.Func.Config.Types
4337	// match: (Rsh8x32 x y)
4338	// result: (Rsh64x64 (SignExt8to64 x) (ZeroExt32to64 y))
4339	for {
4340		y := v.Args[1]
4341		x := v.Args[0]
4342		v.reset(OpRsh64x64)
4343		v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
4344		v0.AddArg(x)
4345		v.AddArg(v0)
4346		v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
4347		v1.AddArg(y)
4348		v.AddArg(v1)
4349		return true
4350	}
4351}
4352func rewriteValueWasm_OpRsh8x64_0(v *Value) bool {
4353	b := v.Block
4354	typ := &b.Func.Config.Types
4355	// match: (Rsh8x64 x y)
4356	// result: (Rsh64x64 (SignExt8to64 x) y)
4357	for {
4358		y := v.Args[1]
4359		x := v.Args[0]
4360		v.reset(OpRsh64x64)
4361		v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
4362		v0.AddArg(x)
4363		v.AddArg(v0)
4364		v.AddArg(y)
4365		return true
4366	}
4367}
4368func rewriteValueWasm_OpRsh8x8_0(v *Value) bool {
4369	b := v.Block
4370	typ := &b.Func.Config.Types
4371	// match: (Rsh8x8 x y)
4372	// result: (Rsh64x64 (SignExt8to64 x) (ZeroExt8to64 y))
4373	for {
4374		y := v.Args[1]
4375		x := v.Args[0]
4376		v.reset(OpRsh64x64)
4377		v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
4378		v0.AddArg(x)
4379		v.AddArg(v0)
4380		v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
4381		v1.AddArg(y)
4382		v.AddArg(v1)
4383		return true
4384	}
4385}
4386func rewriteValueWasm_OpSignExt16to32_0(v *Value) bool {
4387	b := v.Block
4388	typ := &b.Func.Config.Types
4389	// match: (SignExt16to32 x:(I64Load16S _ _))
4390	// result: x
4391	for {
4392		x := v.Args[0]
4393		if x.Op != OpWasmI64Load16S {
4394			break
4395		}
4396		_ = x.Args[1]
4397		v.reset(OpCopy)
4398		v.Type = x.Type
4399		v.AddArg(x)
4400		return true
4401	}
4402	// match: (SignExt16to32 x)
4403	// cond: objabi.GOWASM.SignExt
4404	// result: (I64Extend16S x)
4405	for {
4406		x := v.Args[0]
4407		if !(objabi.GOWASM.SignExt) {
4408			break
4409		}
4410		v.reset(OpWasmI64Extend16S)
4411		v.AddArg(x)
4412		return true
4413	}
4414	// match: (SignExt16to32 x)
4415	// result: (I64ShrS (I64Shl x (I64Const [48])) (I64Const [48]))
4416	for {
4417		x := v.Args[0]
4418		v.reset(OpWasmI64ShrS)
4419		v0 := b.NewValue0(v.Pos, OpWasmI64Shl, typ.Int64)
4420		v0.AddArg(x)
4421		v1 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
4422		v1.AuxInt = 48
4423		v0.AddArg(v1)
4424		v.AddArg(v0)
4425		v2 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
4426		v2.AuxInt = 48
4427		v.AddArg(v2)
4428		return true
4429	}
4430}
4431func rewriteValueWasm_OpSignExt16to64_0(v *Value) bool {
4432	b := v.Block
4433	typ := &b.Func.Config.Types
4434	// match: (SignExt16to64 x:(I64Load16S _ _))
4435	// result: x
4436	for {
4437		x := v.Args[0]
4438		if x.Op != OpWasmI64Load16S {
4439			break
4440		}
4441		_ = x.Args[1]
4442		v.reset(OpCopy)
4443		v.Type = x.Type
4444		v.AddArg(x)
4445		return true
4446	}
4447	// match: (SignExt16to64 x)
4448	// cond: objabi.GOWASM.SignExt
4449	// result: (I64Extend16S x)
4450	for {
4451		x := v.Args[0]
4452		if !(objabi.GOWASM.SignExt) {
4453			break
4454		}
4455		v.reset(OpWasmI64Extend16S)
4456		v.AddArg(x)
4457		return true
4458	}
4459	// match: (SignExt16to64 x)
4460	// result: (I64ShrS (I64Shl x (I64Const [48])) (I64Const [48]))
4461	for {
4462		x := v.Args[0]
4463		v.reset(OpWasmI64ShrS)
4464		v0 := b.NewValue0(v.Pos, OpWasmI64Shl, typ.Int64)
4465		v0.AddArg(x)
4466		v1 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
4467		v1.AuxInt = 48
4468		v0.AddArg(v1)
4469		v.AddArg(v0)
4470		v2 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
4471		v2.AuxInt = 48
4472		v.AddArg(v2)
4473		return true
4474	}
4475}
4476func rewriteValueWasm_OpSignExt32to64_0(v *Value) bool {
4477	b := v.Block
4478	typ := &b.Func.Config.Types
4479	// match: (SignExt32to64 x:(I64Load32S _ _))
4480	// result: x
4481	for {
4482		x := v.Args[0]
4483		if x.Op != OpWasmI64Load32S {
4484			break
4485		}
4486		_ = x.Args[1]
4487		v.reset(OpCopy)
4488		v.Type = x.Type
4489		v.AddArg(x)
4490		return true
4491	}
4492	// match: (SignExt32to64 x)
4493	// cond: objabi.GOWASM.SignExt
4494	// result: (I64Extend32S x)
4495	for {
4496		x := v.Args[0]
4497		if !(objabi.GOWASM.SignExt) {
4498			break
4499		}
4500		v.reset(OpWasmI64Extend32S)
4501		v.AddArg(x)
4502		return true
4503	}
4504	// match: (SignExt32to64 x)
4505	// result: (I64ShrS (I64Shl x (I64Const [32])) (I64Const [32]))
4506	for {
4507		x := v.Args[0]
4508		v.reset(OpWasmI64ShrS)
4509		v0 := b.NewValue0(v.Pos, OpWasmI64Shl, typ.Int64)
4510		v0.AddArg(x)
4511		v1 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
4512		v1.AuxInt = 32
4513		v0.AddArg(v1)
4514		v.AddArg(v0)
4515		v2 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
4516		v2.AuxInt = 32
4517		v.AddArg(v2)
4518		return true
4519	}
4520}
4521func rewriteValueWasm_OpSignExt8to16_0(v *Value) bool {
4522	b := v.Block
4523	typ := &b.Func.Config.Types
4524	// match: (SignExt8to16 x:(I64Load8S _ _))
4525	// result: x
4526	for {
4527		x := v.Args[0]
4528		if x.Op != OpWasmI64Load8S {
4529			break
4530		}
4531		_ = x.Args[1]
4532		v.reset(OpCopy)
4533		v.Type = x.Type
4534		v.AddArg(x)
4535		return true
4536	}
4537	// match: (SignExt8to16 x)
4538	// cond: objabi.GOWASM.SignExt
4539	// result: (I64Extend8S x)
4540	for {
4541		x := v.Args[0]
4542		if !(objabi.GOWASM.SignExt) {
4543			break
4544		}
4545		v.reset(OpWasmI64Extend8S)
4546		v.AddArg(x)
4547		return true
4548	}
4549	// match: (SignExt8to16 x)
4550	// result: (I64ShrS (I64Shl x (I64Const [56])) (I64Const [56]))
4551	for {
4552		x := v.Args[0]
4553		v.reset(OpWasmI64ShrS)
4554		v0 := b.NewValue0(v.Pos, OpWasmI64Shl, typ.Int64)
4555		v0.AddArg(x)
4556		v1 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
4557		v1.AuxInt = 56
4558		v0.AddArg(v1)
4559		v.AddArg(v0)
4560		v2 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
4561		v2.AuxInt = 56
4562		v.AddArg(v2)
4563		return true
4564	}
4565}
4566func rewriteValueWasm_OpSignExt8to32_0(v *Value) bool {
4567	b := v.Block
4568	typ := &b.Func.Config.Types
4569	// match: (SignExt8to32 x:(I64Load8S _ _))
4570	// result: x
4571	for {
4572		x := v.Args[0]
4573		if x.Op != OpWasmI64Load8S {
4574			break
4575		}
4576		_ = x.Args[1]
4577		v.reset(OpCopy)
4578		v.Type = x.Type
4579		v.AddArg(x)
4580		return true
4581	}
4582	// match: (SignExt8to32 x)
4583	// cond: objabi.GOWASM.SignExt
4584	// result: (I64Extend8S x)
4585	for {
4586		x := v.Args[0]
4587		if !(objabi.GOWASM.SignExt) {
4588			break
4589		}
4590		v.reset(OpWasmI64Extend8S)
4591		v.AddArg(x)
4592		return true
4593	}
4594	// match: (SignExt8to32 x)
4595	// result: (I64ShrS (I64Shl x (I64Const [56])) (I64Const [56]))
4596	for {
4597		x := v.Args[0]
4598		v.reset(OpWasmI64ShrS)
4599		v0 := b.NewValue0(v.Pos, OpWasmI64Shl, typ.Int64)
4600		v0.AddArg(x)
4601		v1 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
4602		v1.AuxInt = 56
4603		v0.AddArg(v1)
4604		v.AddArg(v0)
4605		v2 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
4606		v2.AuxInt = 56
4607		v.AddArg(v2)
4608		return true
4609	}
4610}
4611func rewriteValueWasm_OpSignExt8to64_0(v *Value) bool {
4612	b := v.Block
4613	typ := &b.Func.Config.Types
4614	// match: (SignExt8to64 x:(I64Load8S _ _))
4615	// result: x
4616	for {
4617		x := v.Args[0]
4618		if x.Op != OpWasmI64Load8S {
4619			break
4620		}
4621		_ = x.Args[1]
4622		v.reset(OpCopy)
4623		v.Type = x.Type
4624		v.AddArg(x)
4625		return true
4626	}
4627	// match: (SignExt8to64 x)
4628	// cond: objabi.GOWASM.SignExt
4629	// result: (I64Extend8S x)
4630	for {
4631		x := v.Args[0]
4632		if !(objabi.GOWASM.SignExt) {
4633			break
4634		}
4635		v.reset(OpWasmI64Extend8S)
4636		v.AddArg(x)
4637		return true
4638	}
4639	// match: (SignExt8to64 x)
4640	// result: (I64ShrS (I64Shl x (I64Const [56])) (I64Const [56]))
4641	for {
4642		x := v.Args[0]
4643		v.reset(OpWasmI64ShrS)
4644		v0 := b.NewValue0(v.Pos, OpWasmI64Shl, typ.Int64)
4645		v0.AddArg(x)
4646		v1 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
4647		v1.AuxInt = 56
4648		v0.AddArg(v1)
4649		v.AddArg(v0)
4650		v2 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
4651		v2.AuxInt = 56
4652		v.AddArg(v2)
4653		return true
4654	}
4655}
4656func rewriteValueWasm_OpSlicemask_0(v *Value) bool {
4657	b := v.Block
4658	typ := &b.Func.Config.Types
4659	// match: (Slicemask x)
4660	// result: (I64ShrS (I64Sub (I64Const [0]) x) (I64Const [63]))
4661	for {
4662		x := v.Args[0]
4663		v.reset(OpWasmI64ShrS)
4664		v0 := b.NewValue0(v.Pos, OpWasmI64Sub, typ.Int64)
4665		v1 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
4666		v1.AuxInt = 0
4667		v0.AddArg(v1)
4668		v0.AddArg(x)
4669		v.AddArg(v0)
4670		v2 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
4671		v2.AuxInt = 63
4672		v.AddArg(v2)
4673		return true
4674	}
4675}
4676func rewriteValueWasm_OpSqrt_0(v *Value) bool {
4677	// match: (Sqrt x)
4678	// result: (F64Sqrt x)
4679	for {
4680		x := v.Args[0]
4681		v.reset(OpWasmF64Sqrt)
4682		v.AddArg(x)
4683		return true
4684	}
4685}
4686func rewriteValueWasm_OpStaticCall_0(v *Value) bool {
4687	// match: (StaticCall [argwid] {target} mem)
4688	// result: (LoweredStaticCall [argwid] {target} mem)
4689	for {
4690		argwid := v.AuxInt
4691		target := v.Aux
4692		mem := v.Args[0]
4693		v.reset(OpWasmLoweredStaticCall)
4694		v.AuxInt = argwid
4695		v.Aux = target
4696		v.AddArg(mem)
4697		return true
4698	}
4699}
4700func rewriteValueWasm_OpStore_0(v *Value) bool {
4701	// match: (Store {t} ptr val mem)
4702	// cond: is64BitFloat(t.(*types.Type))
4703	// result: (F64Store ptr val mem)
4704	for {
4705		t := v.Aux
4706		mem := v.Args[2]
4707		ptr := v.Args[0]
4708		val := v.Args[1]
4709		if !(is64BitFloat(t.(*types.Type))) {
4710			break
4711		}
4712		v.reset(OpWasmF64Store)
4713		v.AddArg(ptr)
4714		v.AddArg(val)
4715		v.AddArg(mem)
4716		return true
4717	}
4718	// match: (Store {t} ptr val mem)
4719	// cond: is32BitFloat(t.(*types.Type))
4720	// result: (F32Store ptr val mem)
4721	for {
4722		t := v.Aux
4723		mem := v.Args[2]
4724		ptr := v.Args[0]
4725		val := v.Args[1]
4726		if !(is32BitFloat(t.(*types.Type))) {
4727			break
4728		}
4729		v.reset(OpWasmF32Store)
4730		v.AddArg(ptr)
4731		v.AddArg(val)
4732		v.AddArg(mem)
4733		return true
4734	}
4735	// match: (Store {t} ptr val mem)
4736	// cond: t.(*types.Type).Size() == 8
4737	// result: (I64Store ptr val mem)
4738	for {
4739		t := v.Aux
4740		mem := v.Args[2]
4741		ptr := v.Args[0]
4742		val := v.Args[1]
4743		if !(t.(*types.Type).Size() == 8) {
4744			break
4745		}
4746		v.reset(OpWasmI64Store)
4747		v.AddArg(ptr)
4748		v.AddArg(val)
4749		v.AddArg(mem)
4750		return true
4751	}
4752	// match: (Store {t} ptr val mem)
4753	// cond: t.(*types.Type).Size() == 4
4754	// result: (I64Store32 ptr val mem)
4755	for {
4756		t := v.Aux
4757		mem := v.Args[2]
4758		ptr := v.Args[0]
4759		val := v.Args[1]
4760		if !(t.(*types.Type).Size() == 4) {
4761			break
4762		}
4763		v.reset(OpWasmI64Store32)
4764		v.AddArg(ptr)
4765		v.AddArg(val)
4766		v.AddArg(mem)
4767		return true
4768	}
4769	// match: (Store {t} ptr val mem)
4770	// cond: t.(*types.Type).Size() == 2
4771	// result: (I64Store16 ptr val mem)
4772	for {
4773		t := v.Aux
4774		mem := v.Args[2]
4775		ptr := v.Args[0]
4776		val := v.Args[1]
4777		if !(t.(*types.Type).Size() == 2) {
4778			break
4779		}
4780		v.reset(OpWasmI64Store16)
4781		v.AddArg(ptr)
4782		v.AddArg(val)
4783		v.AddArg(mem)
4784		return true
4785	}
4786	// match: (Store {t} ptr val mem)
4787	// cond: t.(*types.Type).Size() == 1
4788	// result: (I64Store8 ptr val mem)
4789	for {
4790		t := v.Aux
4791		mem := v.Args[2]
4792		ptr := v.Args[0]
4793		val := v.Args[1]
4794		if !(t.(*types.Type).Size() == 1) {
4795			break
4796		}
4797		v.reset(OpWasmI64Store8)
4798		v.AddArg(ptr)
4799		v.AddArg(val)
4800		v.AddArg(mem)
4801		return true
4802	}
4803	return false
4804}
4805func rewriteValueWasm_OpSub16_0(v *Value) bool {
4806	// match: (Sub16 x y)
4807	// result: (I64Sub x y)
4808	for {
4809		y := v.Args[1]
4810		x := v.Args[0]
4811		v.reset(OpWasmI64Sub)
4812		v.AddArg(x)
4813		v.AddArg(y)
4814		return true
4815	}
4816}
4817func rewriteValueWasm_OpSub32_0(v *Value) bool {
4818	// match: (Sub32 x y)
4819	// result: (I64Sub x y)
4820	for {
4821		y := v.Args[1]
4822		x := v.Args[0]
4823		v.reset(OpWasmI64Sub)
4824		v.AddArg(x)
4825		v.AddArg(y)
4826		return true
4827	}
4828}
4829func rewriteValueWasm_OpSub32F_0(v *Value) bool {
4830	// match: (Sub32F x y)
4831	// result: (F32Sub x y)
4832	for {
4833		y := v.Args[1]
4834		x := v.Args[0]
4835		v.reset(OpWasmF32Sub)
4836		v.AddArg(x)
4837		v.AddArg(y)
4838		return true
4839	}
4840}
4841func rewriteValueWasm_OpSub64_0(v *Value) bool {
4842	// match: (Sub64 x y)
4843	// result: (I64Sub x y)
4844	for {
4845		y := v.Args[1]
4846		x := v.Args[0]
4847		v.reset(OpWasmI64Sub)
4848		v.AddArg(x)
4849		v.AddArg(y)
4850		return true
4851	}
4852}
4853func rewriteValueWasm_OpSub64F_0(v *Value) bool {
4854	// match: (Sub64F x y)
4855	// result: (F64Sub x y)
4856	for {
4857		y := v.Args[1]
4858		x := v.Args[0]
4859		v.reset(OpWasmF64Sub)
4860		v.AddArg(x)
4861		v.AddArg(y)
4862		return true
4863	}
4864}
4865func rewriteValueWasm_OpSub8_0(v *Value) bool {
4866	// match: (Sub8 x y)
4867	// result: (I64Sub x y)
4868	for {
4869		y := v.Args[1]
4870		x := v.Args[0]
4871		v.reset(OpWasmI64Sub)
4872		v.AddArg(x)
4873		v.AddArg(y)
4874		return true
4875	}
4876}
4877func rewriteValueWasm_OpSubPtr_0(v *Value) bool {
4878	// match: (SubPtr x y)
4879	// result: (I64Sub x y)
4880	for {
4881		y := v.Args[1]
4882		x := v.Args[0]
4883		v.reset(OpWasmI64Sub)
4884		v.AddArg(x)
4885		v.AddArg(y)
4886		return true
4887	}
4888}
4889func rewriteValueWasm_OpTrunc_0(v *Value) bool {
4890	// match: (Trunc x)
4891	// result: (F64Trunc x)
4892	for {
4893		x := v.Args[0]
4894		v.reset(OpWasmF64Trunc)
4895		v.AddArg(x)
4896		return true
4897	}
4898}
4899func rewriteValueWasm_OpTrunc16to8_0(v *Value) bool {
4900	// match: (Trunc16to8 x)
4901	// result: x
4902	for {
4903		x := v.Args[0]
4904		v.reset(OpCopy)
4905		v.Type = x.Type
4906		v.AddArg(x)
4907		return true
4908	}
4909}
4910func rewriteValueWasm_OpTrunc32to16_0(v *Value) bool {
4911	// match: (Trunc32to16 x)
4912	// result: x
4913	for {
4914		x := v.Args[0]
4915		v.reset(OpCopy)
4916		v.Type = x.Type
4917		v.AddArg(x)
4918		return true
4919	}
4920}
4921func rewriteValueWasm_OpTrunc32to8_0(v *Value) bool {
4922	// match: (Trunc32to8 x)
4923	// result: x
4924	for {
4925		x := v.Args[0]
4926		v.reset(OpCopy)
4927		v.Type = x.Type
4928		v.AddArg(x)
4929		return true
4930	}
4931}
4932func rewriteValueWasm_OpTrunc64to16_0(v *Value) bool {
4933	// match: (Trunc64to16 x)
4934	// result: x
4935	for {
4936		x := v.Args[0]
4937		v.reset(OpCopy)
4938		v.Type = x.Type
4939		v.AddArg(x)
4940		return true
4941	}
4942}
4943func rewriteValueWasm_OpTrunc64to32_0(v *Value) bool {
4944	// match: (Trunc64to32 x)
4945	// result: x
4946	for {
4947		x := v.Args[0]
4948		v.reset(OpCopy)
4949		v.Type = x.Type
4950		v.AddArg(x)
4951		return true
4952	}
4953}
4954func rewriteValueWasm_OpTrunc64to8_0(v *Value) bool {
4955	// match: (Trunc64to8 x)
4956	// result: x
4957	for {
4958		x := v.Args[0]
4959		v.reset(OpCopy)
4960		v.Type = x.Type
4961		v.AddArg(x)
4962		return true
4963	}
4964}
4965func rewriteValueWasm_OpWB_0(v *Value) bool {
4966	// match: (WB {fn} destptr srcptr mem)
4967	// result: (LoweredWB {fn} destptr srcptr mem)
4968	for {
4969		fn := v.Aux
4970		mem := v.Args[2]
4971		destptr := v.Args[0]
4972		srcptr := v.Args[1]
4973		v.reset(OpWasmLoweredWB)
4974		v.Aux = fn
4975		v.AddArg(destptr)
4976		v.AddArg(srcptr)
4977		v.AddArg(mem)
4978		return true
4979	}
4980}
4981func rewriteValueWasm_OpWasmF64Add_0(v *Value) bool {
4982	b := v.Block
4983	typ := &b.Func.Config.Types
4984	// match: (F64Add (F64Const [x]) (F64Const [y]))
4985	// result: (F64Const [auxFrom64F(auxTo64F(x) + auxTo64F(y))])
4986	for {
4987		_ = v.Args[1]
4988		v_0 := v.Args[0]
4989		if v_0.Op != OpWasmF64Const {
4990			break
4991		}
4992		x := v_0.AuxInt
4993		v_1 := v.Args[1]
4994		if v_1.Op != OpWasmF64Const {
4995			break
4996		}
4997		y := v_1.AuxInt
4998		v.reset(OpWasmF64Const)
4999		v.AuxInt = auxFrom64F(auxTo64F(x) + auxTo64F(y))
5000		return true
5001	}
5002	// match: (F64Add (F64Const [x]) y)
5003	// result: (F64Add y (F64Const [x]))
5004	for {
5005		y := v.Args[1]
5006		v_0 := v.Args[0]
5007		if v_0.Op != OpWasmF64Const {
5008			break
5009		}
5010		x := v_0.AuxInt
5011		v.reset(OpWasmF64Add)
5012		v.AddArg(y)
5013		v0 := b.NewValue0(v.Pos, OpWasmF64Const, typ.Float64)
5014		v0.AuxInt = x
5015		v.AddArg(v0)
5016		return true
5017	}
5018	return false
5019}
5020func rewriteValueWasm_OpWasmF64Mul_0(v *Value) bool {
5021	b := v.Block
5022	typ := &b.Func.Config.Types
5023	// match: (F64Mul (F64Const [x]) (F64Const [y]))
5024	// result: (F64Const [auxFrom64F(auxTo64F(x) * auxTo64F(y))])
5025	for {
5026		_ = v.Args[1]
5027		v_0 := v.Args[0]
5028		if v_0.Op != OpWasmF64Const {
5029			break
5030		}
5031		x := v_0.AuxInt
5032		v_1 := v.Args[1]
5033		if v_1.Op != OpWasmF64Const {
5034			break
5035		}
5036		y := v_1.AuxInt
5037		v.reset(OpWasmF64Const)
5038		v.AuxInt = auxFrom64F(auxTo64F(x) * auxTo64F(y))
5039		return true
5040	}
5041	// match: (F64Mul (F64Const [x]) y)
5042	// result: (F64Mul y (F64Const [x]))
5043	for {
5044		y := v.Args[1]
5045		v_0 := v.Args[0]
5046		if v_0.Op != OpWasmF64Const {
5047			break
5048		}
5049		x := v_0.AuxInt
5050		v.reset(OpWasmF64Mul)
5051		v.AddArg(y)
5052		v0 := b.NewValue0(v.Pos, OpWasmF64Const, typ.Float64)
5053		v0.AuxInt = x
5054		v.AddArg(v0)
5055		return true
5056	}
5057	return false
5058}
5059func rewriteValueWasm_OpWasmI64Add_0(v *Value) bool {
5060	b := v.Block
5061	typ := &b.Func.Config.Types
5062	// match: (I64Add (I64Const [x]) (I64Const [y]))
5063	// result: (I64Const [x + y])
5064	for {
5065		_ = v.Args[1]
5066		v_0 := v.Args[0]
5067		if v_0.Op != OpWasmI64Const {
5068			break
5069		}
5070		x := v_0.AuxInt
5071		v_1 := v.Args[1]
5072		if v_1.Op != OpWasmI64Const {
5073			break
5074		}
5075		y := v_1.AuxInt
5076		v.reset(OpWasmI64Const)
5077		v.AuxInt = x + y
5078		return true
5079	}
5080	// match: (I64Add (I64Const [x]) y)
5081	// result: (I64Add y (I64Const [x]))
5082	for {
5083		y := v.Args[1]
5084		v_0 := v.Args[0]
5085		if v_0.Op != OpWasmI64Const {
5086			break
5087		}
5088		x := v_0.AuxInt
5089		v.reset(OpWasmI64Add)
5090		v.AddArg(y)
5091		v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
5092		v0.AuxInt = x
5093		v.AddArg(v0)
5094		return true
5095	}
5096	// match: (I64Add x (I64Const [y]))
5097	// result: (I64AddConst [y] x)
5098	for {
5099		_ = v.Args[1]
5100		x := v.Args[0]
5101		v_1 := v.Args[1]
5102		if v_1.Op != OpWasmI64Const {
5103			break
5104		}
5105		y := v_1.AuxInt
5106		v.reset(OpWasmI64AddConst)
5107		v.AuxInt = y
5108		v.AddArg(x)
5109		return true
5110	}
5111	return false
5112}
5113func rewriteValueWasm_OpWasmI64AddConst_0(v *Value) bool {
5114	// match: (I64AddConst [0] x)
5115	// result: x
5116	for {
5117		if v.AuxInt != 0 {
5118			break
5119		}
5120		x := v.Args[0]
5121		v.reset(OpCopy)
5122		v.Type = x.Type
5123		v.AddArg(x)
5124		return true
5125	}
5126	// match: (I64AddConst [off] (LoweredAddr {sym} [off2] base))
5127	// cond: isU32Bit(off+off2)
5128	// result: (LoweredAddr {sym} [off+off2] base)
5129	for {
5130		off := v.AuxInt
5131		v_0 := v.Args[0]
5132		if v_0.Op != OpWasmLoweredAddr {
5133			break
5134		}
5135		off2 := v_0.AuxInt
5136		sym := v_0.Aux
5137		base := v_0.Args[0]
5138		if !(isU32Bit(off + off2)) {
5139			break
5140		}
5141		v.reset(OpWasmLoweredAddr)
5142		v.AuxInt = off + off2
5143		v.Aux = sym
5144		v.AddArg(base)
5145		return true
5146	}
5147	return false
5148}
5149func rewriteValueWasm_OpWasmI64And_0(v *Value) bool {
5150	b := v.Block
5151	typ := &b.Func.Config.Types
5152	// match: (I64And (I64Const [x]) (I64Const [y]))
5153	// result: (I64Const [x & y])
5154	for {
5155		_ = v.Args[1]
5156		v_0 := v.Args[0]
5157		if v_0.Op != OpWasmI64Const {
5158			break
5159		}
5160		x := v_0.AuxInt
5161		v_1 := v.Args[1]
5162		if v_1.Op != OpWasmI64Const {
5163			break
5164		}
5165		y := v_1.AuxInt
5166		v.reset(OpWasmI64Const)
5167		v.AuxInt = x & y
5168		return true
5169	}
5170	// match: (I64And (I64Const [x]) y)
5171	// result: (I64And y (I64Const [x]))
5172	for {
5173		y := v.Args[1]
5174		v_0 := v.Args[0]
5175		if v_0.Op != OpWasmI64Const {
5176			break
5177		}
5178		x := v_0.AuxInt
5179		v.reset(OpWasmI64And)
5180		v.AddArg(y)
5181		v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
5182		v0.AuxInt = x
5183		v.AddArg(v0)
5184		return true
5185	}
5186	return false
5187}
5188func rewriteValueWasm_OpWasmI64Eq_0(v *Value) bool {
5189	b := v.Block
5190	typ := &b.Func.Config.Types
5191	// match: (I64Eq (I64Const [x]) (I64Const [y]))
5192	// cond: x == y
5193	// result: (I64Const [1])
5194	for {
5195		_ = v.Args[1]
5196		v_0 := v.Args[0]
5197		if v_0.Op != OpWasmI64Const {
5198			break
5199		}
5200		x := v_0.AuxInt
5201		v_1 := v.Args[1]
5202		if v_1.Op != OpWasmI64Const {
5203			break
5204		}
5205		y := v_1.AuxInt
5206		if !(x == y) {
5207			break
5208		}
5209		v.reset(OpWasmI64Const)
5210		v.AuxInt = 1
5211		return true
5212	}
5213	// match: (I64Eq (I64Const [x]) (I64Const [y]))
5214	// cond: x != y
5215	// result: (I64Const [0])
5216	for {
5217		_ = v.Args[1]
5218		v_0 := v.Args[0]
5219		if v_0.Op != OpWasmI64Const {
5220			break
5221		}
5222		x := v_0.AuxInt
5223		v_1 := v.Args[1]
5224		if v_1.Op != OpWasmI64Const {
5225			break
5226		}
5227		y := v_1.AuxInt
5228		if !(x != y) {
5229			break
5230		}
5231		v.reset(OpWasmI64Const)
5232		v.AuxInt = 0
5233		return true
5234	}
5235	// match: (I64Eq (I64Const [x]) y)
5236	// result: (I64Eq y (I64Const [x]))
5237	for {
5238		y := v.Args[1]
5239		v_0 := v.Args[0]
5240		if v_0.Op != OpWasmI64Const {
5241			break
5242		}
5243		x := v_0.AuxInt
5244		v.reset(OpWasmI64Eq)
5245		v.AddArg(y)
5246		v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
5247		v0.AuxInt = x
5248		v.AddArg(v0)
5249		return true
5250	}
5251	// match: (I64Eq x (I64Const [0]))
5252	// result: (I64Eqz x)
5253	for {
5254		_ = v.Args[1]
5255		x := v.Args[0]
5256		v_1 := v.Args[1]
5257		if v_1.Op != OpWasmI64Const || v_1.AuxInt != 0 {
5258			break
5259		}
5260		v.reset(OpWasmI64Eqz)
5261		v.AddArg(x)
5262		return true
5263	}
5264	return false
5265}
5266func rewriteValueWasm_OpWasmI64Eqz_0(v *Value) bool {
5267	// match: (I64Eqz (I64Eqz (I64Eqz x)))
5268	// result: (I64Eqz x)
5269	for {
5270		v_0 := v.Args[0]
5271		if v_0.Op != OpWasmI64Eqz {
5272			break
5273		}
5274		v_0_0 := v_0.Args[0]
5275		if v_0_0.Op != OpWasmI64Eqz {
5276			break
5277		}
5278		x := v_0_0.Args[0]
5279		v.reset(OpWasmI64Eqz)
5280		v.AddArg(x)
5281		return true
5282	}
5283	return false
5284}
5285func rewriteValueWasm_OpWasmI64Load_0(v *Value) bool {
5286	b := v.Block
5287	config := b.Func.Config
5288	// match: (I64Load [off] (I64AddConst [off2] ptr) mem)
5289	// cond: isU32Bit(off+off2)
5290	// result: (I64Load [off+off2] ptr mem)
5291	for {
5292		off := v.AuxInt
5293		mem := v.Args[1]
5294		v_0 := v.Args[0]
5295		if v_0.Op != OpWasmI64AddConst {
5296			break
5297		}
5298		off2 := v_0.AuxInt
5299		ptr := v_0.Args[0]
5300		if !(isU32Bit(off + off2)) {
5301			break
5302		}
5303		v.reset(OpWasmI64Load)
5304		v.AuxInt = off + off2
5305		v.AddArg(ptr)
5306		v.AddArg(mem)
5307		return true
5308	}
5309	// match: (I64Load [off] (LoweredAddr {sym} [off2] (SB)) _)
5310	// cond: symIsRO(sym) && isU32Bit(off+off2)
5311	// result: (I64Const [int64(read64(sym, off+off2, config.BigEndian))])
5312	for {
5313		off := v.AuxInt
5314		_ = v.Args[1]
5315		v_0 := v.Args[0]
5316		if v_0.Op != OpWasmLoweredAddr {
5317			break
5318		}
5319		off2 := v_0.AuxInt
5320		sym := v_0.Aux
5321		v_0_0 := v_0.Args[0]
5322		if v_0_0.Op != OpSB || !(symIsRO(sym) && isU32Bit(off+off2)) {
5323			break
5324		}
5325		v.reset(OpWasmI64Const)
5326		v.AuxInt = int64(read64(sym, off+off2, config.BigEndian))
5327		return true
5328	}
5329	return false
5330}
5331func rewriteValueWasm_OpWasmI64Load16S_0(v *Value) bool {
5332	// match: (I64Load16S [off] (I64AddConst [off2] ptr) mem)
5333	// cond: isU32Bit(off+off2)
5334	// result: (I64Load16S [off+off2] ptr mem)
5335	for {
5336		off := v.AuxInt
5337		mem := v.Args[1]
5338		v_0 := v.Args[0]
5339		if v_0.Op != OpWasmI64AddConst {
5340			break
5341		}
5342		off2 := v_0.AuxInt
5343		ptr := v_0.Args[0]
5344		if !(isU32Bit(off + off2)) {
5345			break
5346		}
5347		v.reset(OpWasmI64Load16S)
5348		v.AuxInt = off + off2
5349		v.AddArg(ptr)
5350		v.AddArg(mem)
5351		return true
5352	}
5353	return false
5354}
5355func rewriteValueWasm_OpWasmI64Load16U_0(v *Value) bool {
5356	b := v.Block
5357	config := b.Func.Config
5358	// match: (I64Load16U [off] (I64AddConst [off2] ptr) mem)
5359	// cond: isU32Bit(off+off2)
5360	// result: (I64Load16U [off+off2] ptr mem)
5361	for {
5362		off := v.AuxInt
5363		mem := v.Args[1]
5364		v_0 := v.Args[0]
5365		if v_0.Op != OpWasmI64AddConst {
5366			break
5367		}
5368		off2 := v_0.AuxInt
5369		ptr := v_0.Args[0]
5370		if !(isU32Bit(off + off2)) {
5371			break
5372		}
5373		v.reset(OpWasmI64Load16U)
5374		v.AuxInt = off + off2
5375		v.AddArg(ptr)
5376		v.AddArg(mem)
5377		return true
5378	}
5379	// match: (I64Load16U [off] (LoweredAddr {sym} [off2] (SB)) _)
5380	// cond: symIsRO(sym) && isU32Bit(off+off2)
5381	// result: (I64Const [int64(read16(sym, off+off2, config.BigEndian))])
5382	for {
5383		off := v.AuxInt
5384		_ = v.Args[1]
5385		v_0 := v.Args[0]
5386		if v_0.Op != OpWasmLoweredAddr {
5387			break
5388		}
5389		off2 := v_0.AuxInt
5390		sym := v_0.Aux
5391		v_0_0 := v_0.Args[0]
5392		if v_0_0.Op != OpSB || !(symIsRO(sym) && isU32Bit(off+off2)) {
5393			break
5394		}
5395		v.reset(OpWasmI64Const)
5396		v.AuxInt = int64(read16(sym, off+off2, config.BigEndian))
5397		return true
5398	}
5399	return false
5400}
5401func rewriteValueWasm_OpWasmI64Load32S_0(v *Value) bool {
5402	// match: (I64Load32S [off] (I64AddConst [off2] ptr) mem)
5403	// cond: isU32Bit(off+off2)
5404	// result: (I64Load32S [off+off2] ptr mem)
5405	for {
5406		off := v.AuxInt
5407		mem := v.Args[1]
5408		v_0 := v.Args[0]
5409		if v_0.Op != OpWasmI64AddConst {
5410			break
5411		}
5412		off2 := v_0.AuxInt
5413		ptr := v_0.Args[0]
5414		if !(isU32Bit(off + off2)) {
5415			break
5416		}
5417		v.reset(OpWasmI64Load32S)
5418		v.AuxInt = off + off2
5419		v.AddArg(ptr)
5420		v.AddArg(mem)
5421		return true
5422	}
5423	return false
5424}
5425func rewriteValueWasm_OpWasmI64Load32U_0(v *Value) bool {
5426	b := v.Block
5427	config := b.Func.Config
5428	// match: (I64Load32U [off] (I64AddConst [off2] ptr) mem)
5429	// cond: isU32Bit(off+off2)
5430	// result: (I64Load32U [off+off2] ptr mem)
5431	for {
5432		off := v.AuxInt
5433		mem := v.Args[1]
5434		v_0 := v.Args[0]
5435		if v_0.Op != OpWasmI64AddConst {
5436			break
5437		}
5438		off2 := v_0.AuxInt
5439		ptr := v_0.Args[0]
5440		if !(isU32Bit(off + off2)) {
5441			break
5442		}
5443		v.reset(OpWasmI64Load32U)
5444		v.AuxInt = off + off2
5445		v.AddArg(ptr)
5446		v.AddArg(mem)
5447		return true
5448	}
5449	// match: (I64Load32U [off] (LoweredAddr {sym} [off2] (SB)) _)
5450	// cond: symIsRO(sym) && isU32Bit(off+off2)
5451	// result: (I64Const [int64(read32(sym, off+off2, config.BigEndian))])
5452	for {
5453		off := v.AuxInt
5454		_ = v.Args[1]
5455		v_0 := v.Args[0]
5456		if v_0.Op != OpWasmLoweredAddr {
5457			break
5458		}
5459		off2 := v_0.AuxInt
5460		sym := v_0.Aux
5461		v_0_0 := v_0.Args[0]
5462		if v_0_0.Op != OpSB || !(symIsRO(sym) && isU32Bit(off+off2)) {
5463			break
5464		}
5465		v.reset(OpWasmI64Const)
5466		v.AuxInt = int64(read32(sym, off+off2, config.BigEndian))
5467		return true
5468	}
5469	return false
5470}
5471func rewriteValueWasm_OpWasmI64Load8S_0(v *Value) bool {
5472	// match: (I64Load8S [off] (I64AddConst [off2] ptr) mem)
5473	// cond: isU32Bit(off+off2)
5474	// result: (I64Load8S [off+off2] ptr mem)
5475	for {
5476		off := v.AuxInt
5477		mem := v.Args[1]
5478		v_0 := v.Args[0]
5479		if v_0.Op != OpWasmI64AddConst {
5480			break
5481		}
5482		off2 := v_0.AuxInt
5483		ptr := v_0.Args[0]
5484		if !(isU32Bit(off + off2)) {
5485			break
5486		}
5487		v.reset(OpWasmI64Load8S)
5488		v.AuxInt = off + off2
5489		v.AddArg(ptr)
5490		v.AddArg(mem)
5491		return true
5492	}
5493	return false
5494}
5495func rewriteValueWasm_OpWasmI64Load8U_0(v *Value) bool {
5496	// match: (I64Load8U [off] (I64AddConst [off2] ptr) mem)
5497	// cond: isU32Bit(off+off2)
5498	// result: (I64Load8U [off+off2] ptr mem)
5499	for {
5500		off := v.AuxInt
5501		mem := v.Args[1]
5502		v_0 := v.Args[0]
5503		if v_0.Op != OpWasmI64AddConst {
5504			break
5505		}
5506		off2 := v_0.AuxInt
5507		ptr := v_0.Args[0]
5508		if !(isU32Bit(off + off2)) {
5509			break
5510		}
5511		v.reset(OpWasmI64Load8U)
5512		v.AuxInt = off + off2
5513		v.AddArg(ptr)
5514		v.AddArg(mem)
5515		return true
5516	}
5517	// match: (I64Load8U [off] (LoweredAddr {sym} [off2] (SB)) _)
5518	// cond: symIsRO(sym) && isU32Bit(off+off2)
5519	// result: (I64Const [int64(read8(sym, off+off2))])
5520	for {
5521		off := v.AuxInt
5522		_ = v.Args[1]
5523		v_0 := v.Args[0]
5524		if v_0.Op != OpWasmLoweredAddr {
5525			break
5526		}
5527		off2 := v_0.AuxInt
5528		sym := v_0.Aux
5529		v_0_0 := v_0.Args[0]
5530		if v_0_0.Op != OpSB || !(symIsRO(sym) && isU32Bit(off+off2)) {
5531			break
5532		}
5533		v.reset(OpWasmI64Const)
5534		v.AuxInt = int64(read8(sym, off+off2))
5535		return true
5536	}
5537	return false
5538}
5539func rewriteValueWasm_OpWasmI64Mul_0(v *Value) bool {
5540	b := v.Block
5541	typ := &b.Func.Config.Types
5542	// match: (I64Mul (I64Const [x]) (I64Const [y]))
5543	// result: (I64Const [x * y])
5544	for {
5545		_ = v.Args[1]
5546		v_0 := v.Args[0]
5547		if v_0.Op != OpWasmI64Const {
5548			break
5549		}
5550		x := v_0.AuxInt
5551		v_1 := v.Args[1]
5552		if v_1.Op != OpWasmI64Const {
5553			break
5554		}
5555		y := v_1.AuxInt
5556		v.reset(OpWasmI64Const)
5557		v.AuxInt = x * y
5558		return true
5559	}
5560	// match: (I64Mul (I64Const [x]) y)
5561	// result: (I64Mul y (I64Const [x]))
5562	for {
5563		y := v.Args[1]
5564		v_0 := v.Args[0]
5565		if v_0.Op != OpWasmI64Const {
5566			break
5567		}
5568		x := v_0.AuxInt
5569		v.reset(OpWasmI64Mul)
5570		v.AddArg(y)
5571		v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
5572		v0.AuxInt = x
5573		v.AddArg(v0)
5574		return true
5575	}
5576	return false
5577}
5578func rewriteValueWasm_OpWasmI64Ne_0(v *Value) bool {
5579	b := v.Block
5580	typ := &b.Func.Config.Types
5581	// match: (I64Ne (I64Const [x]) (I64Const [y]))
5582	// cond: x == y
5583	// result: (I64Const [0])
5584	for {
5585		_ = v.Args[1]
5586		v_0 := v.Args[0]
5587		if v_0.Op != OpWasmI64Const {
5588			break
5589		}
5590		x := v_0.AuxInt
5591		v_1 := v.Args[1]
5592		if v_1.Op != OpWasmI64Const {
5593			break
5594		}
5595		y := v_1.AuxInt
5596		if !(x == y) {
5597			break
5598		}
5599		v.reset(OpWasmI64Const)
5600		v.AuxInt = 0
5601		return true
5602	}
5603	// match: (I64Ne (I64Const [x]) (I64Const [y]))
5604	// cond: x != y
5605	// result: (I64Const [1])
5606	for {
5607		_ = v.Args[1]
5608		v_0 := v.Args[0]
5609		if v_0.Op != OpWasmI64Const {
5610			break
5611		}
5612		x := v_0.AuxInt
5613		v_1 := v.Args[1]
5614		if v_1.Op != OpWasmI64Const {
5615			break
5616		}
5617		y := v_1.AuxInt
5618		if !(x != y) {
5619			break
5620		}
5621		v.reset(OpWasmI64Const)
5622		v.AuxInt = 1
5623		return true
5624	}
5625	// match: (I64Ne (I64Const [x]) y)
5626	// result: (I64Ne y (I64Const [x]))
5627	for {
5628		y := v.Args[1]
5629		v_0 := v.Args[0]
5630		if v_0.Op != OpWasmI64Const {
5631			break
5632		}
5633		x := v_0.AuxInt
5634		v.reset(OpWasmI64Ne)
5635		v.AddArg(y)
5636		v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
5637		v0.AuxInt = x
5638		v.AddArg(v0)
5639		return true
5640	}
5641	// match: (I64Ne x (I64Const [0]))
5642	// result: (I64Eqz (I64Eqz x))
5643	for {
5644		_ = v.Args[1]
5645		x := v.Args[0]
5646		v_1 := v.Args[1]
5647		if v_1.Op != OpWasmI64Const || v_1.AuxInt != 0 {
5648			break
5649		}
5650		v.reset(OpWasmI64Eqz)
5651		v0 := b.NewValue0(v.Pos, OpWasmI64Eqz, typ.Bool)
5652		v0.AddArg(x)
5653		v.AddArg(v0)
5654		return true
5655	}
5656	return false
5657}
5658func rewriteValueWasm_OpWasmI64Or_0(v *Value) bool {
5659	b := v.Block
5660	typ := &b.Func.Config.Types
5661	// match: (I64Or (I64Const [x]) (I64Const [y]))
5662	// result: (I64Const [x | y])
5663	for {
5664		_ = v.Args[1]
5665		v_0 := v.Args[0]
5666		if v_0.Op != OpWasmI64Const {
5667			break
5668		}
5669		x := v_0.AuxInt
5670		v_1 := v.Args[1]
5671		if v_1.Op != OpWasmI64Const {
5672			break
5673		}
5674		y := v_1.AuxInt
5675		v.reset(OpWasmI64Const)
5676		v.AuxInt = x | y
5677		return true
5678	}
5679	// match: (I64Or (I64Const [x]) y)
5680	// result: (I64Or y (I64Const [x]))
5681	for {
5682		y := v.Args[1]
5683		v_0 := v.Args[0]
5684		if v_0.Op != OpWasmI64Const {
5685			break
5686		}
5687		x := v_0.AuxInt
5688		v.reset(OpWasmI64Or)
5689		v.AddArg(y)
5690		v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
5691		v0.AuxInt = x
5692		v.AddArg(v0)
5693		return true
5694	}
5695	return false
5696}
5697func rewriteValueWasm_OpWasmI64Shl_0(v *Value) bool {
5698	// match: (I64Shl (I64Const [x]) (I64Const [y]))
5699	// result: (I64Const [x << uint64(y)])
5700	for {
5701		_ = v.Args[1]
5702		v_0 := v.Args[0]
5703		if v_0.Op != OpWasmI64Const {
5704			break
5705		}
5706		x := v_0.AuxInt
5707		v_1 := v.Args[1]
5708		if v_1.Op != OpWasmI64Const {
5709			break
5710		}
5711		y := v_1.AuxInt
5712		v.reset(OpWasmI64Const)
5713		v.AuxInt = x << uint64(y)
5714		return true
5715	}
5716	return false
5717}
5718func rewriteValueWasm_OpWasmI64ShrS_0(v *Value) bool {
5719	// match: (I64ShrS (I64Const [x]) (I64Const [y]))
5720	// result: (I64Const [x >> uint64(y)])
5721	for {
5722		_ = v.Args[1]
5723		v_0 := v.Args[0]
5724		if v_0.Op != OpWasmI64Const {
5725			break
5726		}
5727		x := v_0.AuxInt
5728		v_1 := v.Args[1]
5729		if v_1.Op != OpWasmI64Const {
5730			break
5731		}
5732		y := v_1.AuxInt
5733		v.reset(OpWasmI64Const)
5734		v.AuxInt = x >> uint64(y)
5735		return true
5736	}
5737	return false
5738}
5739func rewriteValueWasm_OpWasmI64ShrU_0(v *Value) bool {
5740	// match: (I64ShrU (I64Const [x]) (I64Const [y]))
5741	// result: (I64Const [int64(uint64(x) >> uint64(y))])
5742	for {
5743		_ = v.Args[1]
5744		v_0 := v.Args[0]
5745		if v_0.Op != OpWasmI64Const {
5746			break
5747		}
5748		x := v_0.AuxInt
5749		v_1 := v.Args[1]
5750		if v_1.Op != OpWasmI64Const {
5751			break
5752		}
5753		y := v_1.AuxInt
5754		v.reset(OpWasmI64Const)
5755		v.AuxInt = int64(uint64(x) >> uint64(y))
5756		return true
5757	}
5758	return false
5759}
5760func rewriteValueWasm_OpWasmI64Store_0(v *Value) bool {
5761	// match: (I64Store [off] (I64AddConst [off2] ptr) val mem)
5762	// cond: isU32Bit(off+off2)
5763	// result: (I64Store [off+off2] ptr val mem)
5764	for {
5765		off := v.AuxInt
5766		mem := v.Args[2]
5767		v_0 := v.Args[0]
5768		if v_0.Op != OpWasmI64AddConst {
5769			break
5770		}
5771		off2 := v_0.AuxInt
5772		ptr := v_0.Args[0]
5773		val := v.Args[1]
5774		if !(isU32Bit(off + off2)) {
5775			break
5776		}
5777		v.reset(OpWasmI64Store)
5778		v.AuxInt = off + off2
5779		v.AddArg(ptr)
5780		v.AddArg(val)
5781		v.AddArg(mem)
5782		return true
5783	}
5784	return false
5785}
5786func rewriteValueWasm_OpWasmI64Store16_0(v *Value) bool {
5787	// match: (I64Store16 [off] (I64AddConst [off2] ptr) val mem)
5788	// cond: isU32Bit(off+off2)
5789	// result: (I64Store16 [off+off2] ptr val mem)
5790	for {
5791		off := v.AuxInt
5792		mem := v.Args[2]
5793		v_0 := v.Args[0]
5794		if v_0.Op != OpWasmI64AddConst {
5795			break
5796		}
5797		off2 := v_0.AuxInt
5798		ptr := v_0.Args[0]
5799		val := v.Args[1]
5800		if !(isU32Bit(off + off2)) {
5801			break
5802		}
5803		v.reset(OpWasmI64Store16)
5804		v.AuxInt = off + off2
5805		v.AddArg(ptr)
5806		v.AddArg(val)
5807		v.AddArg(mem)
5808		return true
5809	}
5810	return false
5811}
5812func rewriteValueWasm_OpWasmI64Store32_0(v *Value) bool {
5813	// match: (I64Store32 [off] (I64AddConst [off2] ptr) val mem)
5814	// cond: isU32Bit(off+off2)
5815	// result: (I64Store32 [off+off2] ptr val mem)
5816	for {
5817		off := v.AuxInt
5818		mem := v.Args[2]
5819		v_0 := v.Args[0]
5820		if v_0.Op != OpWasmI64AddConst {
5821			break
5822		}
5823		off2 := v_0.AuxInt
5824		ptr := v_0.Args[0]
5825		val := v.Args[1]
5826		if !(isU32Bit(off + off2)) {
5827			break
5828		}
5829		v.reset(OpWasmI64Store32)
5830		v.AuxInt = off + off2
5831		v.AddArg(ptr)
5832		v.AddArg(val)
5833		v.AddArg(mem)
5834		return true
5835	}
5836	return false
5837}
5838func rewriteValueWasm_OpWasmI64Store8_0(v *Value) bool {
5839	// match: (I64Store8 [off] (I64AddConst [off2] ptr) val mem)
5840	// cond: isU32Bit(off+off2)
5841	// result: (I64Store8 [off+off2] ptr val mem)
5842	for {
5843		off := v.AuxInt
5844		mem := v.Args[2]
5845		v_0 := v.Args[0]
5846		if v_0.Op != OpWasmI64AddConst {
5847			break
5848		}
5849		off2 := v_0.AuxInt
5850		ptr := v_0.Args[0]
5851		val := v.Args[1]
5852		if !(isU32Bit(off + off2)) {
5853			break
5854		}
5855		v.reset(OpWasmI64Store8)
5856		v.AuxInt = off + off2
5857		v.AddArg(ptr)
5858		v.AddArg(val)
5859		v.AddArg(mem)
5860		return true
5861	}
5862	return false
5863}
5864func rewriteValueWasm_OpWasmI64Xor_0(v *Value) bool {
5865	b := v.Block
5866	typ := &b.Func.Config.Types
5867	// match: (I64Xor (I64Const [x]) (I64Const [y]))
5868	// result: (I64Const [x ^ y])
5869	for {
5870		_ = v.Args[1]
5871		v_0 := v.Args[0]
5872		if v_0.Op != OpWasmI64Const {
5873			break
5874		}
5875		x := v_0.AuxInt
5876		v_1 := v.Args[1]
5877		if v_1.Op != OpWasmI64Const {
5878			break
5879		}
5880		y := v_1.AuxInt
5881		v.reset(OpWasmI64Const)
5882		v.AuxInt = x ^ y
5883		return true
5884	}
5885	// match: (I64Xor (I64Const [x]) y)
5886	// result: (I64Xor y (I64Const [x]))
5887	for {
5888		y := v.Args[1]
5889		v_0 := v.Args[0]
5890		if v_0.Op != OpWasmI64Const {
5891			break
5892		}
5893		x := v_0.AuxInt
5894		v.reset(OpWasmI64Xor)
5895		v.AddArg(y)
5896		v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
5897		v0.AuxInt = x
5898		v.AddArg(v0)
5899		return true
5900	}
5901	return false
5902}
5903func rewriteValueWasm_OpXor16_0(v *Value) bool {
5904	// match: (Xor16 x y)
5905	// result: (I64Xor x y)
5906	for {
5907		y := v.Args[1]
5908		x := v.Args[0]
5909		v.reset(OpWasmI64Xor)
5910		v.AddArg(x)
5911		v.AddArg(y)
5912		return true
5913	}
5914}
5915func rewriteValueWasm_OpXor32_0(v *Value) bool {
5916	// match: (Xor32 x y)
5917	// result: (I64Xor x y)
5918	for {
5919		y := v.Args[1]
5920		x := v.Args[0]
5921		v.reset(OpWasmI64Xor)
5922		v.AddArg(x)
5923		v.AddArg(y)
5924		return true
5925	}
5926}
5927func rewriteValueWasm_OpXor64_0(v *Value) bool {
5928	// match: (Xor64 x y)
5929	// result: (I64Xor x y)
5930	for {
5931		y := v.Args[1]
5932		x := v.Args[0]
5933		v.reset(OpWasmI64Xor)
5934		v.AddArg(x)
5935		v.AddArg(y)
5936		return true
5937	}
5938}
5939func rewriteValueWasm_OpXor8_0(v *Value) bool {
5940	// match: (Xor8 x y)
5941	// result: (I64Xor x y)
5942	for {
5943		y := v.Args[1]
5944		x := v.Args[0]
5945		v.reset(OpWasmI64Xor)
5946		v.AddArg(x)
5947		v.AddArg(y)
5948		return true
5949	}
5950}
5951func rewriteValueWasm_OpZero_0(v *Value) bool {
5952	b := v.Block
5953	typ := &b.Func.Config.Types
5954	// match: (Zero [0] _ mem)
5955	// result: mem
5956	for {
5957		if v.AuxInt != 0 {
5958			break
5959		}
5960		mem := v.Args[1]
5961		v.reset(OpCopy)
5962		v.Type = mem.Type
5963		v.AddArg(mem)
5964		return true
5965	}
5966	// match: (Zero [1] destptr mem)
5967	// result: (I64Store8 destptr (I64Const [0]) mem)
5968	for {
5969		if v.AuxInt != 1 {
5970			break
5971		}
5972		mem := v.Args[1]
5973		destptr := v.Args[0]
5974		v.reset(OpWasmI64Store8)
5975		v.AddArg(destptr)
5976		v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
5977		v0.AuxInt = 0
5978		v.AddArg(v0)
5979		v.AddArg(mem)
5980		return true
5981	}
5982	// match: (Zero [2] destptr mem)
5983	// result: (I64Store16 destptr (I64Const [0]) mem)
5984	for {
5985		if v.AuxInt != 2 {
5986			break
5987		}
5988		mem := v.Args[1]
5989		destptr := v.Args[0]
5990		v.reset(OpWasmI64Store16)
5991		v.AddArg(destptr)
5992		v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
5993		v0.AuxInt = 0
5994		v.AddArg(v0)
5995		v.AddArg(mem)
5996		return true
5997	}
5998	// match: (Zero [4] destptr mem)
5999	// result: (I64Store32 destptr (I64Const [0]) mem)
6000	for {
6001		if v.AuxInt != 4 {
6002			break
6003		}
6004		mem := v.Args[1]
6005		destptr := v.Args[0]
6006		v.reset(OpWasmI64Store32)
6007		v.AddArg(destptr)
6008		v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
6009		v0.AuxInt = 0
6010		v.AddArg(v0)
6011		v.AddArg(mem)
6012		return true
6013	}
6014	// match: (Zero [8] destptr mem)
6015	// result: (I64Store destptr (I64Const [0]) mem)
6016	for {
6017		if v.AuxInt != 8 {
6018			break
6019		}
6020		mem := v.Args[1]
6021		destptr := v.Args[0]
6022		v.reset(OpWasmI64Store)
6023		v.AddArg(destptr)
6024		v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
6025		v0.AuxInt = 0
6026		v.AddArg(v0)
6027		v.AddArg(mem)
6028		return true
6029	}
6030	// match: (Zero [3] destptr mem)
6031	// result: (I64Store8 [2] destptr (I64Const [0]) (I64Store16 destptr (I64Const [0]) mem))
6032	for {
6033		if v.AuxInt != 3 {
6034			break
6035		}
6036		mem := v.Args[1]
6037		destptr := v.Args[0]
6038		v.reset(OpWasmI64Store8)
6039		v.AuxInt = 2
6040		v.AddArg(destptr)
6041		v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
6042		v0.AuxInt = 0
6043		v.AddArg(v0)
6044		v1 := b.NewValue0(v.Pos, OpWasmI64Store16, types.TypeMem)
6045		v1.AddArg(destptr)
6046		v2 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
6047		v2.AuxInt = 0
6048		v1.AddArg(v2)
6049		v1.AddArg(mem)
6050		v.AddArg(v1)
6051		return true
6052	}
6053	// match: (Zero [5] destptr mem)
6054	// result: (I64Store8 [4] destptr (I64Const [0]) (I64Store32 destptr (I64Const [0]) mem))
6055	for {
6056		if v.AuxInt != 5 {
6057			break
6058		}
6059		mem := v.Args[1]
6060		destptr := v.Args[0]
6061		v.reset(OpWasmI64Store8)
6062		v.AuxInt = 4
6063		v.AddArg(destptr)
6064		v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
6065		v0.AuxInt = 0
6066		v.AddArg(v0)
6067		v1 := b.NewValue0(v.Pos, OpWasmI64Store32, types.TypeMem)
6068		v1.AddArg(destptr)
6069		v2 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
6070		v2.AuxInt = 0
6071		v1.AddArg(v2)
6072		v1.AddArg(mem)
6073		v.AddArg(v1)
6074		return true
6075	}
6076	// match: (Zero [6] destptr mem)
6077	// result: (I64Store16 [4] destptr (I64Const [0]) (I64Store32 destptr (I64Const [0]) mem))
6078	for {
6079		if v.AuxInt != 6 {
6080			break
6081		}
6082		mem := v.Args[1]
6083		destptr := v.Args[0]
6084		v.reset(OpWasmI64Store16)
6085		v.AuxInt = 4
6086		v.AddArg(destptr)
6087		v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
6088		v0.AuxInt = 0
6089		v.AddArg(v0)
6090		v1 := b.NewValue0(v.Pos, OpWasmI64Store32, types.TypeMem)
6091		v1.AddArg(destptr)
6092		v2 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
6093		v2.AuxInt = 0
6094		v1.AddArg(v2)
6095		v1.AddArg(mem)
6096		v.AddArg(v1)
6097		return true
6098	}
6099	// match: (Zero [7] destptr mem)
6100	// result: (I64Store32 [3] destptr (I64Const [0]) (I64Store32 destptr (I64Const [0]) mem))
6101	for {
6102		if v.AuxInt != 7 {
6103			break
6104		}
6105		mem := v.Args[1]
6106		destptr := v.Args[0]
6107		v.reset(OpWasmI64Store32)
6108		v.AuxInt = 3
6109		v.AddArg(destptr)
6110		v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
6111		v0.AuxInt = 0
6112		v.AddArg(v0)
6113		v1 := b.NewValue0(v.Pos, OpWasmI64Store32, types.TypeMem)
6114		v1.AddArg(destptr)
6115		v2 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
6116		v2.AuxInt = 0
6117		v1.AddArg(v2)
6118		v1.AddArg(mem)
6119		v.AddArg(v1)
6120		return true
6121	}
6122	// match: (Zero [s] destptr mem)
6123	// cond: s%8 != 0 && s > 8
6124	// result: (Zero [s-s%8] (OffPtr <destptr.Type> destptr [s%8]) (I64Store destptr (I64Const [0]) mem))
6125	for {
6126		s := v.AuxInt
6127		mem := v.Args[1]
6128		destptr := v.Args[0]
6129		if !(s%8 != 0 && s > 8) {
6130			break
6131		}
6132		v.reset(OpZero)
6133		v.AuxInt = s - s%8
6134		v0 := b.NewValue0(v.Pos, OpOffPtr, destptr.Type)
6135		v0.AuxInt = s % 8
6136		v0.AddArg(destptr)
6137		v.AddArg(v0)
6138		v1 := b.NewValue0(v.Pos, OpWasmI64Store, types.TypeMem)
6139		v1.AddArg(destptr)
6140		v2 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
6141		v2.AuxInt = 0
6142		v1.AddArg(v2)
6143		v1.AddArg(mem)
6144		v.AddArg(v1)
6145		return true
6146	}
6147	return false
6148}
6149func rewriteValueWasm_OpZero_10(v *Value) bool {
6150	b := v.Block
6151	typ := &b.Func.Config.Types
6152	// match: (Zero [16] destptr mem)
6153	// result: (I64Store [8] destptr (I64Const [0]) (I64Store destptr (I64Const [0]) mem))
6154	for {
6155		if v.AuxInt != 16 {
6156			break
6157		}
6158		mem := v.Args[1]
6159		destptr := v.Args[0]
6160		v.reset(OpWasmI64Store)
6161		v.AuxInt = 8
6162		v.AddArg(destptr)
6163		v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
6164		v0.AuxInt = 0
6165		v.AddArg(v0)
6166		v1 := b.NewValue0(v.Pos, OpWasmI64Store, types.TypeMem)
6167		v1.AddArg(destptr)
6168		v2 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
6169		v2.AuxInt = 0
6170		v1.AddArg(v2)
6171		v1.AddArg(mem)
6172		v.AddArg(v1)
6173		return true
6174	}
6175	// match: (Zero [24] destptr mem)
6176	// result: (I64Store [16] destptr (I64Const [0]) (I64Store [8] destptr (I64Const [0]) (I64Store destptr (I64Const [0]) mem)))
6177	for {
6178		if v.AuxInt != 24 {
6179			break
6180		}
6181		mem := v.Args[1]
6182		destptr := v.Args[0]
6183		v.reset(OpWasmI64Store)
6184		v.AuxInt = 16
6185		v.AddArg(destptr)
6186		v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
6187		v0.AuxInt = 0
6188		v.AddArg(v0)
6189		v1 := b.NewValue0(v.Pos, OpWasmI64Store, types.TypeMem)
6190		v1.AuxInt = 8
6191		v1.AddArg(destptr)
6192		v2 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
6193		v2.AuxInt = 0
6194		v1.AddArg(v2)
6195		v3 := b.NewValue0(v.Pos, OpWasmI64Store, types.TypeMem)
6196		v3.AddArg(destptr)
6197		v4 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
6198		v4.AuxInt = 0
6199		v3.AddArg(v4)
6200		v3.AddArg(mem)
6201		v1.AddArg(v3)
6202		v.AddArg(v1)
6203		return true
6204	}
6205	// match: (Zero [32] destptr mem)
6206	// result: (I64Store [24] destptr (I64Const [0]) (I64Store [16] destptr (I64Const [0]) (I64Store [8] destptr (I64Const [0]) (I64Store destptr (I64Const [0]) mem))))
6207	for {
6208		if v.AuxInt != 32 {
6209			break
6210		}
6211		mem := v.Args[1]
6212		destptr := v.Args[0]
6213		v.reset(OpWasmI64Store)
6214		v.AuxInt = 24
6215		v.AddArg(destptr)
6216		v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
6217		v0.AuxInt = 0
6218		v.AddArg(v0)
6219		v1 := b.NewValue0(v.Pos, OpWasmI64Store, types.TypeMem)
6220		v1.AuxInt = 16
6221		v1.AddArg(destptr)
6222		v2 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
6223		v2.AuxInt = 0
6224		v1.AddArg(v2)
6225		v3 := b.NewValue0(v.Pos, OpWasmI64Store, types.TypeMem)
6226		v3.AuxInt = 8
6227		v3.AddArg(destptr)
6228		v4 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
6229		v4.AuxInt = 0
6230		v3.AddArg(v4)
6231		v5 := b.NewValue0(v.Pos, OpWasmI64Store, types.TypeMem)
6232		v5.AddArg(destptr)
6233		v6 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
6234		v6.AuxInt = 0
6235		v5.AddArg(v6)
6236		v5.AddArg(mem)
6237		v3.AddArg(v5)
6238		v1.AddArg(v3)
6239		v.AddArg(v1)
6240		return true
6241	}
6242	// match: (Zero [s] destptr mem)
6243	// cond: s%8 == 0 && s > 32
6244	// result: (LoweredZero [s/8] destptr mem)
6245	for {
6246		s := v.AuxInt
6247		mem := v.Args[1]
6248		destptr := v.Args[0]
6249		if !(s%8 == 0 && s > 32) {
6250			break
6251		}
6252		v.reset(OpWasmLoweredZero)
6253		v.AuxInt = s / 8
6254		v.AddArg(destptr)
6255		v.AddArg(mem)
6256		return true
6257	}
6258	return false
6259}
6260func rewriteValueWasm_OpZeroExt16to32_0(v *Value) bool {
6261	b := v.Block
6262	typ := &b.Func.Config.Types
6263	// match: (ZeroExt16to32 x:(I64Load16U _ _))
6264	// result: x
6265	for {
6266		x := v.Args[0]
6267		if x.Op != OpWasmI64Load16U {
6268			break
6269		}
6270		_ = x.Args[1]
6271		v.reset(OpCopy)
6272		v.Type = x.Type
6273		v.AddArg(x)
6274		return true
6275	}
6276	// match: (ZeroExt16to32 x)
6277	// result: (I64And x (I64Const [0xffff]))
6278	for {
6279		x := v.Args[0]
6280		v.reset(OpWasmI64And)
6281		v.AddArg(x)
6282		v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
6283		v0.AuxInt = 0xffff
6284		v.AddArg(v0)
6285		return true
6286	}
6287}
6288func rewriteValueWasm_OpZeroExt16to64_0(v *Value) bool {
6289	b := v.Block
6290	typ := &b.Func.Config.Types
6291	// match: (ZeroExt16to64 x:(I64Load16U _ _))
6292	// result: x
6293	for {
6294		x := v.Args[0]
6295		if x.Op != OpWasmI64Load16U {
6296			break
6297		}
6298		_ = x.Args[1]
6299		v.reset(OpCopy)
6300		v.Type = x.Type
6301		v.AddArg(x)
6302		return true
6303	}
6304	// match: (ZeroExt16to64 x)
6305	// result: (I64And x (I64Const [0xffff]))
6306	for {
6307		x := v.Args[0]
6308		v.reset(OpWasmI64And)
6309		v.AddArg(x)
6310		v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
6311		v0.AuxInt = 0xffff
6312		v.AddArg(v0)
6313		return true
6314	}
6315}
6316func rewriteValueWasm_OpZeroExt32to64_0(v *Value) bool {
6317	b := v.Block
6318	typ := &b.Func.Config.Types
6319	// match: (ZeroExt32to64 x:(I64Load32U _ _))
6320	// result: x
6321	for {
6322		x := v.Args[0]
6323		if x.Op != OpWasmI64Load32U {
6324			break
6325		}
6326		_ = x.Args[1]
6327		v.reset(OpCopy)
6328		v.Type = x.Type
6329		v.AddArg(x)
6330		return true
6331	}
6332	// match: (ZeroExt32to64 x)
6333	// result: (I64And x (I64Const [0xffffffff]))
6334	for {
6335		x := v.Args[0]
6336		v.reset(OpWasmI64And)
6337		v.AddArg(x)
6338		v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
6339		v0.AuxInt = 0xffffffff
6340		v.AddArg(v0)
6341		return true
6342	}
6343}
6344func rewriteValueWasm_OpZeroExt8to16_0(v *Value) bool {
6345	b := v.Block
6346	typ := &b.Func.Config.Types
6347	// match: (ZeroExt8to16 x:(I64Load8U _ _))
6348	// result: x
6349	for {
6350		x := v.Args[0]
6351		if x.Op != OpWasmI64Load8U {
6352			break
6353		}
6354		_ = x.Args[1]
6355		v.reset(OpCopy)
6356		v.Type = x.Type
6357		v.AddArg(x)
6358		return true
6359	}
6360	// match: (ZeroExt8to16 x)
6361	// result: (I64And x (I64Const [0xff]))
6362	for {
6363		x := v.Args[0]
6364		v.reset(OpWasmI64And)
6365		v.AddArg(x)
6366		v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
6367		v0.AuxInt = 0xff
6368		v.AddArg(v0)
6369		return true
6370	}
6371}
6372func rewriteValueWasm_OpZeroExt8to32_0(v *Value) bool {
6373	b := v.Block
6374	typ := &b.Func.Config.Types
6375	// match: (ZeroExt8to32 x:(I64Load8U _ _))
6376	// result: x
6377	for {
6378		x := v.Args[0]
6379		if x.Op != OpWasmI64Load8U {
6380			break
6381		}
6382		_ = x.Args[1]
6383		v.reset(OpCopy)
6384		v.Type = x.Type
6385		v.AddArg(x)
6386		return true
6387	}
6388	// match: (ZeroExt8to32 x)
6389	// result: (I64And x (I64Const [0xff]))
6390	for {
6391		x := v.Args[0]
6392		v.reset(OpWasmI64And)
6393		v.AddArg(x)
6394		v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
6395		v0.AuxInt = 0xff
6396		v.AddArg(v0)
6397		return true
6398	}
6399}
6400func rewriteValueWasm_OpZeroExt8to64_0(v *Value) bool {
6401	b := v.Block
6402	typ := &b.Func.Config.Types
6403	// match: (ZeroExt8to64 x:(I64Load8U _ _))
6404	// result: x
6405	for {
6406		x := v.Args[0]
6407		if x.Op != OpWasmI64Load8U {
6408			break
6409		}
6410		_ = x.Args[1]
6411		v.reset(OpCopy)
6412		v.Type = x.Type
6413		v.AddArg(x)
6414		return true
6415	}
6416	// match: (ZeroExt8to64 x)
6417	// result: (I64And x (I64Const [0xff]))
6418	for {
6419		x := v.Args[0]
6420		v.reset(OpWasmI64And)
6421		v.AddArg(x)
6422		v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
6423		v0.AuxInt = 0xff
6424		v.AddArg(v0)
6425		return true
6426	}
6427}
6428func rewriteBlockWasm(b *Block) bool {
6429	switch b.Kind {
6430	}
6431	return false
6432}
6433