1// -------------------------------------------------------------
2// DO NOT EDIT! this file was generated automatically by gomacro
3// Any change will be lost when the file is re-generated
4// -------------------------------------------------------------
5
6/*
7 * gomacro - A Go interpreter with Lisp-like macros
8 *
9 * Copyright (C) 2017-2019 Massimiliano Ghilardi
10 *
11 *     This Source Code Form is subject to the terms of the Mozilla Public
12 *     License, v. 2.0. If a copy of the MPL was not distributed with this
13 *     file, You can obtain one at http://mozilla.org/MPL/2.0/.
14 *
15 *
16 * func2ret0.go
17 *
18 *  Created on Apr 16, 2017
19 *      Author Massimiliano Ghilardi
20 */
21
22package fast
23
24import (
25	r "reflect"
26	"unsafe"
27
28	. "github.com/cosmos72/gomacro/base"
29	"github.com/cosmos72/gomacro/base/reflect"
30	xr "github.com/cosmos72/gomacro/xreflect"
31)
32
33func (c *Comp) func2ret0(t xr.Type, m *funcMaker) func(*Env) r.Value {
34	karg0 := t.In(0).Kind()
35	karg1 := t.In(1).Kind()
36
37	if !reflect.IsOptimizedKind(karg0) || !reflect.IsOptimizedKind(karg1) {
38		return nil
39	}
40
41	indexes := &[2]int{
42		m.Param[0].Desc.Index(),
43		m.Param[1].Desc.Index(),
44	}
45	var debugC *Comp
46	if c.Globals.Options&OptDebugger != 0 {
47		debugC = c
48	}
49
50	var ret func(*Env) r.Value
51	switch karg0 {
52	case r.Bool:
53		ret = func2ret0Bool(m, indexes, karg1, debugC)
54
55	case r.Int:
56		ret = func2ret0Int(m, indexes, karg1, debugC)
57
58	case r.Int8:
59		ret = func2ret0Int8(m, indexes, karg1, debugC)
60
61	case r.Int16:
62		ret = func2ret0Int16(m, indexes, karg1, debugC)
63
64	case r.Int32:
65		ret = func2ret0Int32(m, indexes, karg1, debugC)
66
67	case r.Int64:
68		ret = func2ret0Int64(m, indexes, karg1, debugC)
69
70	case r.Uint:
71		ret = func2ret0Uint(m, indexes, karg1, debugC)
72
73	case r.Uint8:
74		ret = func2ret0Uint8(m, indexes, karg1, debugC)
75
76	case r.Uint16:
77		ret = func2ret0Uint16(m, indexes, karg1, debugC)
78
79	case r.Uint32:
80		ret = func2ret0Uint32(m, indexes, karg1, debugC)
81
82	case r.Uint64:
83		ret = func2ret0Uint64(m, indexes, karg1, debugC)
84
85	case r.Uintptr:
86		ret = func2ret0Uintptr(m, indexes, karg1, debugC)
87
88	case r.Float32:
89		ret = func2ret0Float32(m, indexes, karg1, debugC)
90
91	case r.Float64:
92		ret = func2ret0Float64(m, indexes, karg1, debugC)
93
94	case r.Complex64:
95		ret = func2ret0Complex64(m, indexes, karg1, debugC)
96
97	case r.Complex128:
98		ret = func2ret0Complex128(m, indexes, karg1, debugC)
99
100	case r.String:
101		ret = func2ret0String(m, indexes, karg1, debugC)
102
103	}
104	return ret
105}
106func func2ret0Bool(m *funcMaker, indexes *[2]int, karg1 r.Kind, debugC *Comp) func(*Env) r.Value {
107
108	nbind := m.nbind
109	nintbind := m.nintbind
110	funcbody := m.funcbody
111	var ret func(*Env) r.Value
112	switch karg1 {
113	case r.Bool:
114
115		{
116			if funcbody == nil {
117				funv := r.ValueOf(func(bool,
118
119					bool,
120
121				) {})
122				ret = func(env *Env) r.Value { return funv }
123
124				break
125			}
126			ret = func(env *Env) r.Value {
127
128				env.MarkUsedByClosure()
129				return r.ValueOf(func(arg0 bool,
130
131					arg1 bool,
132
133				) {
134					env := newEnv4Func(env, nbind, nintbind, debugC)
135
136					*(*bool)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
137
138					*(*bool)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
139
140					funcbody(env)
141
142					env.freeEnv4Func()
143				})
144			}
145		}
146	case r.Int:
147
148		{
149			if funcbody == nil {
150				funv := r.ValueOf(func(bool,
151
152					int,
153
154				) {})
155				ret = func(env *Env) r.Value { return funv }
156
157				break
158			}
159			ret = func(env *Env) r.Value {
160
161				env.MarkUsedByClosure()
162				return r.ValueOf(func(arg0 bool,
163
164					arg1 int,
165
166				) {
167					env := newEnv4Func(env, nbind, nintbind, debugC)
168
169					*(*bool)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
170
171					*(*int)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
172
173					funcbody(env)
174
175					env.freeEnv4Func()
176				})
177			}
178		}
179	case r.Int8:
180
181		{
182			if funcbody == nil {
183				funv := r.ValueOf(func(bool,
184
185					int8,
186
187				) {})
188				ret = func(env *Env) r.Value { return funv }
189
190				break
191			}
192			ret = func(env *Env) r.Value {
193
194				env.MarkUsedByClosure()
195				return r.ValueOf(func(arg0 bool,
196
197					arg1 int8,
198
199				) {
200					env := newEnv4Func(env, nbind, nintbind, debugC)
201
202					*(*bool)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
203
204					*(*int8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
205
206					funcbody(env)
207
208					env.freeEnv4Func()
209				})
210			}
211		}
212	case r.Int16:
213		{
214			if funcbody == nil {
215				funv := r.ValueOf(func(bool,
216
217					int16,
218
219				) {})
220				ret = func(env *Env) r.Value { return funv }
221
222				break
223			}
224			ret = func(env *Env) r.Value {
225
226				env.MarkUsedByClosure()
227				return r.ValueOf(func(arg0 bool,
228
229					arg1 int16,
230
231				) {
232					env := newEnv4Func(env, nbind, nintbind, debugC)
233
234					*(*bool)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
235
236					*(*int16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
237
238					funcbody(env)
239
240					env.freeEnv4Func()
241				})
242			}
243		}
244	case r.Int32:
245		{
246			if funcbody == nil {
247				funv := r.ValueOf(func(bool,
248
249					int32,
250
251				) {})
252				ret = func(env *Env) r.Value { return funv }
253
254				break
255			}
256			ret = func(env *Env) r.Value {
257
258				env.MarkUsedByClosure()
259				return r.ValueOf(func(arg0 bool,
260
261					arg1 int32,
262
263				) {
264					env := newEnv4Func(env, nbind, nintbind, debugC)
265
266					*(*bool)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
267
268					*(*int32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
269
270					funcbody(env)
271
272					env.freeEnv4Func()
273				})
274			}
275		}
276	case r.Int64:
277		{
278			if funcbody == nil {
279				funv := r.ValueOf(func(bool,
280
281					int64,
282				) {})
283				ret = func(env *Env) r.Value { return funv }
284
285				break
286			}
287			ret = func(env *Env) r.Value {
288
289				env.MarkUsedByClosure()
290				return r.ValueOf(func(arg0 bool,
291
292					arg1 int64,
293
294				) {
295					env := newEnv4Func(env, nbind, nintbind, debugC)
296
297					*(*bool)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
298
299					*(*int64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
300
301					funcbody(env)
302
303					env.freeEnv4Func()
304				})
305			}
306		}
307	case r.Uint:
308		{
309			if funcbody == nil {
310				funv := r.ValueOf(func(bool,
311
312					uint) {})
313				ret = func(env *Env) r.Value { return funv }
314
315				break
316			}
317			ret = func(env *Env) r.Value {
318
319				env.MarkUsedByClosure()
320				return r.ValueOf(func(arg0 bool,
321
322					arg1 uint,
323
324				) {
325					env := newEnv4Func(env, nbind, nintbind, debugC)
326
327					*(*bool)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
328
329					*(*uint)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
330
331					funcbody(env)
332
333					env.freeEnv4Func()
334				})
335			}
336		}
337	case r.Uint8:
338		{
339			if funcbody == nil {
340				funv := r.ValueOf(func(bool,
341
342					uint8) {})
343				ret = func(env *Env) r.Value { return funv }
344
345				break
346			}
347			ret = func(env *Env) r.Value {
348
349				env.MarkUsedByClosure()
350				return r.ValueOf(func(arg0 bool,
351
352					arg1 uint8,
353
354				) {
355					env := newEnv4Func(env, nbind, nintbind, debugC)
356
357					*(*bool)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
358
359					*(*uint8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
360
361					funcbody(env)
362
363					env.freeEnv4Func()
364				})
365			}
366		}
367	case r.Uint16:
368		{
369			if funcbody == nil {
370				funv := r.ValueOf(func(bool,
371
372					uint16) {})
373				ret = func(env *Env) r.Value { return funv }
374
375				break
376			}
377			ret = func(env *Env) r.Value {
378
379				env.MarkUsedByClosure()
380				return r.ValueOf(func(arg0 bool,
381
382					arg1 uint16,
383
384				) {
385					env := newEnv4Func(env, nbind, nintbind, debugC)
386
387					*(*bool)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
388
389					*(*uint16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
390
391					funcbody(env)
392
393					env.freeEnv4Func()
394				})
395			}
396		}
397	case r.Uint32:
398		{
399			if funcbody == nil {
400				funv := r.ValueOf(func(bool,
401
402					uint32) {})
403				ret = func(env *Env) r.Value { return funv }
404
405				break
406			}
407			ret = func(env *Env) r.Value {
408
409				env.MarkUsedByClosure()
410				return r.ValueOf(func(arg0 bool,
411
412					arg1 uint32,
413
414				) {
415					env := newEnv4Func(env, nbind, nintbind, debugC)
416
417					*(*bool)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
418
419					*(*uint32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
420
421					funcbody(env)
422
423					env.freeEnv4Func()
424				})
425			}
426		}
427	case r.Uint64:
428		{
429			if funcbody == nil {
430				funv := r.ValueOf(func(bool,
431
432					uint64) {})
433				ret = func(env *Env) r.Value { return funv }
434
435				break
436			}
437			ret = func(env *Env) r.Value {
438
439				env.MarkUsedByClosure()
440				return r.ValueOf(func(arg0 bool,
441
442					arg1 uint64,
443
444				) {
445					env := newEnv4Func(env, nbind, nintbind, debugC)
446
447					*(*bool)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
448
449					env.Ints[indexes[1]] = arg1
450
451					funcbody(env)
452
453					env.freeEnv4Func()
454				})
455			}
456		}
457	case r.Uintptr:
458		{
459			if funcbody == nil {
460				funv := r.ValueOf(func(bool,
461
462					uintptr) {})
463				ret = func(env *Env) r.Value { return funv }
464
465				break
466			}
467			ret = func(env *Env) r.Value {
468
469				env.MarkUsedByClosure()
470				return r.ValueOf(func(arg0 bool,
471
472					arg1 uintptr,
473
474				) {
475					env := newEnv4Func(env, nbind, nintbind, debugC)
476
477					*(*bool)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
478
479					*(*uintptr)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
480
481					funcbody(env)
482
483					env.freeEnv4Func()
484				})
485			}
486		}
487	case r.Float32:
488		{
489			if funcbody == nil {
490				funv := r.ValueOf(func(bool,
491
492					float32) {})
493				ret = func(env *Env) r.Value { return funv }
494
495				break
496			}
497			ret = func(env *Env) r.Value {
498
499				env.MarkUsedByClosure()
500				return r.ValueOf(func(arg0 bool,
501
502					arg1 float32,
503
504				) {
505					env := newEnv4Func(env, nbind, nintbind, debugC)
506
507					*(*bool)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
508
509					*(*float32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
510
511					funcbody(env)
512
513					env.freeEnv4Func()
514				})
515			}
516		}
517	case r.Float64:
518		{
519			if funcbody == nil {
520				funv := r.ValueOf(func(bool,
521
522					float64) {})
523				ret = func(env *Env) r.Value { return funv }
524
525				break
526			}
527			ret = func(env *Env) r.Value {
528
529				env.MarkUsedByClosure()
530				return r.ValueOf(func(arg0 bool,
531
532					arg1 float64,
533
534				) {
535					env := newEnv4Func(env, nbind, nintbind, debugC)
536
537					*(*bool)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
538
539					*(*float64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
540
541					funcbody(env)
542
543					env.freeEnv4Func()
544				})
545			}
546		}
547	case r.Complex64:
548		{
549			if funcbody == nil {
550				funv := r.ValueOf(func(bool,
551
552					complex64) {})
553				ret = func(env *Env) r.Value { return funv }
554
555				break
556			}
557			ret = func(env *Env) r.Value {
558
559				env.MarkUsedByClosure()
560				return r.ValueOf(func(arg0 bool,
561
562					arg1 complex64,
563				) {
564					env := newEnv4Func(env, nbind, nintbind, debugC)
565
566					*(*bool)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
567
568					*(*complex64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
569
570					funcbody(env)
571
572					env.freeEnv4Func()
573				})
574			}
575		}
576	case r.Complex128:
577		{
578			if funcbody == nil {
579				funv := r.ValueOf(func(bool,
580
581					complex128) {})
582				ret = func(env *Env) r.Value { return funv }
583
584				break
585			}
586			ret = func(env *Env) r.Value {
587
588				env.MarkUsedByClosure()
589				return r.ValueOf(func(arg0 bool,
590
591					arg1 complex128) {
592					env := newEnv4Func(env, nbind, nintbind, debugC)
593
594					*(*bool)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
595
596					*(*complex128)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
597
598					funcbody(env)
599
600					env.freeEnv4Func()
601				})
602			}
603		}
604	case r.String:
605		{
606			if funcbody == nil {
607				funv := r.ValueOf(func(bool,
608
609					string) {})
610				ret = func(env *Env) r.Value { return funv }
611
612				break
613			}
614			ret = func(env *Env) r.Value {
615
616				env.MarkUsedByClosure()
617				return r.ValueOf(func(arg0 bool,
618
619					arg1 string) {
620					env := newEnv4Func(env, nbind, nintbind, debugC)
621
622					*(*bool)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
623
624					{
625						place := r.New(TypeOfString).Elem()
626						place.SetString(arg1,
627						)
628						env.Vals[indexes[1]] = place
629					}
630
631					funcbody(env)
632
633					env.freeEnv4Func()
634				})
635			}
636		}
637	}
638	return ret
639}
640func func2ret0Int(m *funcMaker, indexes *[2]int, karg1 r.Kind, debugC *Comp) func(*Env) r.Value {
641
642	nbind := m.nbind
643	nintbind := m.nintbind
644	funcbody := m.funcbody
645	var ret func(*Env) r.Value
646	switch karg1 {
647	case r.Bool:
648
649		{
650			if funcbody == nil {
651				funv := r.ValueOf(func(int,
652
653					bool,
654
655				) {})
656				ret = func(env *Env) r.Value { return funv }
657
658				break
659			}
660			ret = func(env *Env) r.Value {
661
662				env.MarkUsedByClosure()
663				return r.ValueOf(func(arg0 int,
664
665					arg1 bool,
666
667				) {
668					env := newEnv4Func(env, nbind, nintbind, debugC)
669
670					*(*int)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
671
672					*(*bool)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
673
674					funcbody(env)
675
676					env.freeEnv4Func()
677				})
678			}
679		}
680	case r.Int:
681
682		{
683			if funcbody == nil {
684				funv := r.ValueOf(func(int,
685
686					int,
687
688				) {})
689				ret = func(env *Env) r.Value { return funv }
690
691				break
692			}
693			ret = func(env *Env) r.Value {
694
695				env.MarkUsedByClosure()
696				return r.ValueOf(func(arg0 int,
697
698					arg1 int,
699
700				) {
701					env := newEnv4Func(env, nbind, nintbind, debugC)
702
703					*(*int)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
704
705					*(*int)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
706
707					funcbody(env)
708
709					env.freeEnv4Func()
710				})
711			}
712		}
713	case r.Int8:
714
715		{
716			if funcbody == nil {
717				funv := r.ValueOf(func(int,
718
719					int8,
720
721				) {})
722				ret = func(env *Env) r.Value { return funv }
723
724				break
725			}
726			ret = func(env *Env) r.Value {
727
728				env.MarkUsedByClosure()
729				return r.ValueOf(func(arg0 int,
730
731					arg1 int8,
732
733				) {
734					env := newEnv4Func(env, nbind, nintbind, debugC)
735
736					*(*int)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
737
738					*(*int8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
739
740					funcbody(env)
741
742					env.freeEnv4Func()
743				})
744			}
745		}
746	case r.Int16:
747		{
748			if funcbody == nil {
749				funv := r.ValueOf(func(int,
750
751					int16,
752
753				) {})
754				ret = func(env *Env) r.Value { return funv }
755
756				break
757			}
758			ret = func(env *Env) r.Value {
759
760				env.MarkUsedByClosure()
761				return r.ValueOf(func(arg0 int,
762
763					arg1 int16,
764
765				) {
766					env := newEnv4Func(env, nbind, nintbind, debugC)
767
768					*(*int)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
769
770					*(*int16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
771
772					funcbody(env)
773
774					env.freeEnv4Func()
775				})
776			}
777		}
778	case r.Int32:
779		{
780			if funcbody == nil {
781				funv := r.ValueOf(func(int,
782
783					int32,
784
785				) {})
786				ret = func(env *Env) r.Value { return funv }
787
788				break
789			}
790			ret = func(env *Env) r.Value {
791
792				env.MarkUsedByClosure()
793				return r.ValueOf(func(arg0 int,
794
795					arg1 int32,
796
797				) {
798					env := newEnv4Func(env, nbind, nintbind, debugC)
799
800					*(*int)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
801
802					*(*int32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
803
804					funcbody(env)
805
806					env.freeEnv4Func()
807				})
808			}
809		}
810	case r.Int64:
811		{
812			if funcbody == nil {
813				funv := r.ValueOf(func(int,
814
815					int64,
816				) {})
817				ret = func(env *Env) r.Value { return funv }
818
819				break
820			}
821			ret = func(env *Env) r.Value {
822
823				env.MarkUsedByClosure()
824				return r.ValueOf(func(arg0 int,
825
826					arg1 int64,
827
828				) {
829					env := newEnv4Func(env, nbind, nintbind, debugC)
830
831					*(*int)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
832
833					*(*int64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
834
835					funcbody(env)
836
837					env.freeEnv4Func()
838				})
839			}
840		}
841	case r.Uint:
842		{
843			if funcbody == nil {
844				funv := r.ValueOf(func(int,
845
846					uint) {})
847				ret = func(env *Env) r.Value { return funv }
848
849				break
850			}
851			ret = func(env *Env) r.Value {
852
853				env.MarkUsedByClosure()
854				return r.ValueOf(func(arg0 int,
855
856					arg1 uint,
857
858				) {
859					env := newEnv4Func(env, nbind, nintbind, debugC)
860
861					*(*int)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
862
863					*(*uint)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
864
865					funcbody(env)
866
867					env.freeEnv4Func()
868				})
869			}
870		}
871	case r.Uint8:
872		{
873			if funcbody == nil {
874				funv := r.ValueOf(func(int,
875
876					uint8) {})
877				ret = func(env *Env) r.Value { return funv }
878
879				break
880			}
881			ret = func(env *Env) r.Value {
882
883				env.MarkUsedByClosure()
884				return r.ValueOf(func(arg0 int,
885
886					arg1 uint8,
887
888				) {
889					env := newEnv4Func(env, nbind, nintbind, debugC)
890
891					*(*int)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
892
893					*(*uint8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
894
895					funcbody(env)
896
897					env.freeEnv4Func()
898				})
899			}
900		}
901	case r.Uint16:
902		{
903			if funcbody == nil {
904				funv := r.ValueOf(func(int,
905
906					uint16) {})
907				ret = func(env *Env) r.Value { return funv }
908
909				break
910			}
911			ret = func(env *Env) r.Value {
912
913				env.MarkUsedByClosure()
914				return r.ValueOf(func(arg0 int,
915
916					arg1 uint16,
917
918				) {
919					env := newEnv4Func(env, nbind, nintbind, debugC)
920
921					*(*int)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
922
923					*(*uint16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
924
925					funcbody(env)
926
927					env.freeEnv4Func()
928				})
929			}
930		}
931	case r.Uint32:
932		{
933			if funcbody == nil {
934				funv := r.ValueOf(func(int,
935
936					uint32) {})
937				ret = func(env *Env) r.Value { return funv }
938
939				break
940			}
941			ret = func(env *Env) r.Value {
942
943				env.MarkUsedByClosure()
944				return r.ValueOf(func(arg0 int,
945
946					arg1 uint32,
947
948				) {
949					env := newEnv4Func(env, nbind, nintbind, debugC)
950
951					*(*int)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
952
953					*(*uint32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
954
955					funcbody(env)
956
957					env.freeEnv4Func()
958				})
959			}
960		}
961	case r.Uint64:
962		{
963			if funcbody == nil {
964				funv := r.ValueOf(func(int,
965
966					uint64) {})
967				ret = func(env *Env) r.Value { return funv }
968
969				break
970			}
971			ret = func(env *Env) r.Value {
972
973				env.MarkUsedByClosure()
974				return r.ValueOf(func(arg0 int,
975
976					arg1 uint64,
977
978				) {
979					env := newEnv4Func(env, nbind, nintbind, debugC)
980
981					*(*int)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
982
983					env.Ints[indexes[1]] = arg1
984
985					funcbody(env)
986
987					env.freeEnv4Func()
988				})
989			}
990		}
991	case r.Uintptr:
992		{
993			if funcbody == nil {
994				funv := r.ValueOf(func(int,
995
996					uintptr) {})
997				ret = func(env *Env) r.Value { return funv }
998
999				break
1000			}
1001			ret = func(env *Env) r.Value {
1002
1003				env.MarkUsedByClosure()
1004				return r.ValueOf(func(arg0 int,
1005
1006					arg1 uintptr,
1007
1008				) {
1009					env := newEnv4Func(env, nbind, nintbind, debugC)
1010
1011					*(*int)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
1012
1013					*(*uintptr)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
1014
1015					funcbody(env)
1016
1017					env.freeEnv4Func()
1018				})
1019			}
1020		}
1021	case r.Float32:
1022		{
1023			if funcbody == nil {
1024				funv := r.ValueOf(func(int,
1025
1026					float32) {})
1027				ret = func(env *Env) r.Value { return funv }
1028
1029				break
1030			}
1031			ret = func(env *Env) r.Value {
1032
1033				env.MarkUsedByClosure()
1034				return r.ValueOf(func(arg0 int,
1035
1036					arg1 float32,
1037
1038				) {
1039					env := newEnv4Func(env, nbind, nintbind, debugC)
1040
1041					*(*int)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
1042
1043					*(*float32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
1044
1045					funcbody(env)
1046
1047					env.freeEnv4Func()
1048				})
1049			}
1050		}
1051	case r.Float64:
1052		{
1053			if funcbody == nil {
1054				funv := r.ValueOf(func(int,
1055
1056					float64) {})
1057				ret = func(env *Env) r.Value { return funv }
1058
1059				break
1060			}
1061			ret = func(env *Env) r.Value {
1062
1063				env.MarkUsedByClosure()
1064				return r.ValueOf(func(arg0 int,
1065
1066					arg1 float64,
1067
1068				) {
1069					env := newEnv4Func(env, nbind, nintbind, debugC)
1070
1071					*(*int)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
1072
1073					*(*float64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
1074
1075					funcbody(env)
1076
1077					env.freeEnv4Func()
1078				})
1079			}
1080		}
1081	case r.Complex64:
1082		{
1083			if funcbody == nil {
1084				funv := r.ValueOf(func(int,
1085
1086					complex64) {})
1087				ret = func(env *Env) r.Value { return funv }
1088
1089				break
1090			}
1091			ret = func(env *Env) r.Value {
1092
1093				env.MarkUsedByClosure()
1094				return r.ValueOf(func(arg0 int,
1095
1096					arg1 complex64,
1097				) {
1098					env := newEnv4Func(env, nbind, nintbind, debugC)
1099
1100					*(*int)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
1101
1102					*(*complex64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
1103
1104					funcbody(env)
1105
1106					env.freeEnv4Func()
1107				})
1108			}
1109		}
1110	case r.Complex128:
1111		{
1112			if funcbody == nil {
1113				funv := r.ValueOf(func(int,
1114
1115					complex128) {})
1116				ret = func(env *Env) r.Value { return funv }
1117
1118				break
1119			}
1120			ret = func(env *Env) r.Value {
1121
1122				env.MarkUsedByClosure()
1123				return r.ValueOf(func(arg0 int,
1124
1125					arg1 complex128) {
1126					env := newEnv4Func(env, nbind, nintbind, debugC)
1127
1128					*(*int)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
1129
1130					*(*complex128)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
1131
1132					funcbody(env)
1133
1134					env.freeEnv4Func()
1135				})
1136			}
1137		}
1138	case r.String:
1139		{
1140			if funcbody == nil {
1141				funv := r.ValueOf(func(int,
1142
1143					string) {})
1144				ret = func(env *Env) r.Value { return funv }
1145
1146				break
1147			}
1148			ret = func(env *Env) r.Value {
1149
1150				env.MarkUsedByClosure()
1151				return r.ValueOf(func(arg0 int,
1152
1153					arg1 string) {
1154					env := newEnv4Func(env, nbind, nintbind, debugC)
1155
1156					*(*int)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
1157
1158					{
1159						place := r.New(TypeOfString).Elem()
1160						place.SetString(arg1,
1161						)
1162						env.Vals[indexes[1]] = place
1163					}
1164
1165					funcbody(env)
1166
1167					env.freeEnv4Func()
1168				})
1169			}
1170		}
1171	}
1172	return ret
1173}
1174func func2ret0Int8(m *funcMaker, indexes *[2]int, karg1 r.Kind, debugC *Comp) func(*Env) r.Value {
1175
1176	nbind := m.nbind
1177	nintbind := m.nintbind
1178	funcbody := m.funcbody
1179	var ret func(*Env) r.Value
1180	switch karg1 {
1181	case r.Bool:
1182
1183		{
1184			if funcbody == nil {
1185				funv := r.ValueOf(func(int8,
1186
1187					bool,
1188
1189				) {})
1190				ret = func(env *Env) r.Value { return funv }
1191
1192				break
1193			}
1194			ret = func(env *Env) r.Value {
1195
1196				env.MarkUsedByClosure()
1197				return r.ValueOf(func(arg0 int8,
1198
1199					arg1 bool,
1200
1201				) {
1202					env := newEnv4Func(env, nbind, nintbind, debugC)
1203
1204					*(*int8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
1205
1206					*(*bool)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
1207
1208					funcbody(env)
1209
1210					env.freeEnv4Func()
1211				})
1212			}
1213		}
1214	case r.Int:
1215
1216		{
1217			if funcbody == nil {
1218				funv := r.ValueOf(func(int8,
1219
1220					int,
1221
1222				) {})
1223				ret = func(env *Env) r.Value { return funv }
1224
1225				break
1226			}
1227			ret = func(env *Env) r.Value {
1228
1229				env.MarkUsedByClosure()
1230				return r.ValueOf(func(arg0 int8,
1231
1232					arg1 int,
1233
1234				) {
1235					env := newEnv4Func(env, nbind, nintbind, debugC)
1236
1237					*(*int8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
1238
1239					*(*int)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
1240
1241					funcbody(env)
1242
1243					env.freeEnv4Func()
1244				})
1245			}
1246		}
1247	case r.Int8:
1248
1249		{
1250			if funcbody == nil {
1251				funv := r.ValueOf(func(int8,
1252
1253					int8,
1254
1255				) {})
1256				ret = func(env *Env) r.Value { return funv }
1257
1258				break
1259			}
1260			ret = func(env *Env) r.Value {
1261
1262				env.MarkUsedByClosure()
1263				return r.ValueOf(func(arg0 int8,
1264
1265					arg1 int8,
1266
1267				) {
1268					env := newEnv4Func(env, nbind, nintbind, debugC)
1269
1270					*(*int8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
1271
1272					*(*int8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
1273
1274					funcbody(env)
1275
1276					env.freeEnv4Func()
1277				})
1278			}
1279		}
1280	case r.Int16:
1281		{
1282			if funcbody == nil {
1283				funv := r.ValueOf(func(int8,
1284
1285					int16,
1286
1287				) {})
1288				ret = func(env *Env) r.Value { return funv }
1289
1290				break
1291			}
1292			ret = func(env *Env) r.Value {
1293
1294				env.MarkUsedByClosure()
1295				return r.ValueOf(func(arg0 int8,
1296
1297					arg1 int16,
1298
1299				) {
1300					env := newEnv4Func(env, nbind, nintbind, debugC)
1301
1302					*(*int8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
1303
1304					*(*int16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
1305
1306					funcbody(env)
1307
1308					env.freeEnv4Func()
1309				})
1310			}
1311		}
1312	case r.Int32:
1313		{
1314			if funcbody == nil {
1315				funv := r.ValueOf(func(int8,
1316
1317					int32,
1318
1319				) {})
1320				ret = func(env *Env) r.Value { return funv }
1321
1322				break
1323			}
1324			ret = func(env *Env) r.Value {
1325
1326				env.MarkUsedByClosure()
1327				return r.ValueOf(func(arg0 int8,
1328
1329					arg1 int32,
1330
1331				) {
1332					env := newEnv4Func(env, nbind, nintbind, debugC)
1333
1334					*(*int8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
1335
1336					*(*int32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
1337
1338					funcbody(env)
1339
1340					env.freeEnv4Func()
1341				})
1342			}
1343		}
1344	case r.Int64:
1345		{
1346			if funcbody == nil {
1347				funv := r.ValueOf(func(int8,
1348
1349					int64,
1350				) {})
1351				ret = func(env *Env) r.Value { return funv }
1352
1353				break
1354			}
1355			ret = func(env *Env) r.Value {
1356
1357				env.MarkUsedByClosure()
1358				return r.ValueOf(func(arg0 int8,
1359
1360					arg1 int64,
1361
1362				) {
1363					env := newEnv4Func(env, nbind, nintbind, debugC)
1364
1365					*(*int8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
1366
1367					*(*int64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
1368
1369					funcbody(env)
1370
1371					env.freeEnv4Func()
1372				})
1373			}
1374		}
1375	case r.Uint:
1376		{
1377			if funcbody == nil {
1378				funv := r.ValueOf(func(int8,
1379
1380					uint) {})
1381				ret = func(env *Env) r.Value { return funv }
1382
1383				break
1384			}
1385			ret = func(env *Env) r.Value {
1386
1387				env.MarkUsedByClosure()
1388				return r.ValueOf(func(arg0 int8,
1389
1390					arg1 uint,
1391
1392				) {
1393					env := newEnv4Func(env, nbind, nintbind, debugC)
1394
1395					*(*int8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
1396
1397					*(*uint)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
1398
1399					funcbody(env)
1400
1401					env.freeEnv4Func()
1402				})
1403			}
1404		}
1405	case r.Uint8:
1406		{
1407			if funcbody == nil {
1408				funv := r.ValueOf(func(int8,
1409
1410					uint8) {})
1411				ret = func(env *Env) r.Value { return funv }
1412
1413				break
1414			}
1415			ret = func(env *Env) r.Value {
1416
1417				env.MarkUsedByClosure()
1418				return r.ValueOf(func(arg0 int8,
1419
1420					arg1 uint8,
1421
1422				) {
1423					env := newEnv4Func(env, nbind, nintbind, debugC)
1424
1425					*(*int8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
1426
1427					*(*uint8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
1428
1429					funcbody(env)
1430
1431					env.freeEnv4Func()
1432				})
1433			}
1434		}
1435	case r.Uint16:
1436		{
1437			if funcbody == nil {
1438				funv := r.ValueOf(func(int8,
1439
1440					uint16) {})
1441				ret = func(env *Env) r.Value { return funv }
1442
1443				break
1444			}
1445			ret = func(env *Env) r.Value {
1446
1447				env.MarkUsedByClosure()
1448				return r.ValueOf(func(arg0 int8,
1449
1450					arg1 uint16,
1451
1452				) {
1453					env := newEnv4Func(env, nbind, nintbind, debugC)
1454
1455					*(*int8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
1456
1457					*(*uint16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
1458
1459					funcbody(env)
1460
1461					env.freeEnv4Func()
1462				})
1463			}
1464		}
1465	case r.Uint32:
1466		{
1467			if funcbody == nil {
1468				funv := r.ValueOf(func(int8,
1469
1470					uint32) {})
1471				ret = func(env *Env) r.Value { return funv }
1472
1473				break
1474			}
1475			ret = func(env *Env) r.Value {
1476
1477				env.MarkUsedByClosure()
1478				return r.ValueOf(func(arg0 int8,
1479
1480					arg1 uint32,
1481
1482				) {
1483					env := newEnv4Func(env, nbind, nintbind, debugC)
1484
1485					*(*int8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
1486
1487					*(*uint32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
1488
1489					funcbody(env)
1490
1491					env.freeEnv4Func()
1492				})
1493			}
1494		}
1495	case r.Uint64:
1496		{
1497			if funcbody == nil {
1498				funv := r.ValueOf(func(int8,
1499
1500					uint64) {})
1501				ret = func(env *Env) r.Value { return funv }
1502
1503				break
1504			}
1505			ret = func(env *Env) r.Value {
1506
1507				env.MarkUsedByClosure()
1508				return r.ValueOf(func(arg0 int8,
1509
1510					arg1 uint64,
1511
1512				) {
1513					env := newEnv4Func(env, nbind, nintbind, debugC)
1514
1515					*(*int8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
1516
1517					env.Ints[indexes[1]] = arg1
1518
1519					funcbody(env)
1520
1521					env.freeEnv4Func()
1522				})
1523			}
1524		}
1525	case r.Uintptr:
1526		{
1527			if funcbody == nil {
1528				funv := r.ValueOf(func(int8,
1529
1530					uintptr) {})
1531				ret = func(env *Env) r.Value { return funv }
1532
1533				break
1534			}
1535			ret = func(env *Env) r.Value {
1536
1537				env.MarkUsedByClosure()
1538				return r.ValueOf(func(arg0 int8,
1539
1540					arg1 uintptr,
1541
1542				) {
1543					env := newEnv4Func(env, nbind, nintbind, debugC)
1544
1545					*(*int8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
1546
1547					*(*uintptr)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
1548
1549					funcbody(env)
1550
1551					env.freeEnv4Func()
1552				})
1553			}
1554		}
1555	case r.Float32:
1556		{
1557			if funcbody == nil {
1558				funv := r.ValueOf(func(int8,
1559
1560					float32) {})
1561				ret = func(env *Env) r.Value { return funv }
1562
1563				break
1564			}
1565			ret = func(env *Env) r.Value {
1566
1567				env.MarkUsedByClosure()
1568				return r.ValueOf(func(arg0 int8,
1569
1570					arg1 float32,
1571
1572				) {
1573					env := newEnv4Func(env, nbind, nintbind, debugC)
1574
1575					*(*int8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
1576
1577					*(*float32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
1578
1579					funcbody(env)
1580
1581					env.freeEnv4Func()
1582				})
1583			}
1584		}
1585	case r.Float64:
1586		{
1587			if funcbody == nil {
1588				funv := r.ValueOf(func(int8,
1589
1590					float64) {})
1591				ret = func(env *Env) r.Value { return funv }
1592
1593				break
1594			}
1595			ret = func(env *Env) r.Value {
1596
1597				env.MarkUsedByClosure()
1598				return r.ValueOf(func(arg0 int8,
1599
1600					arg1 float64,
1601
1602				) {
1603					env := newEnv4Func(env, nbind, nintbind, debugC)
1604
1605					*(*int8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
1606
1607					*(*float64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
1608
1609					funcbody(env)
1610
1611					env.freeEnv4Func()
1612				})
1613			}
1614		}
1615	case r.Complex64:
1616		{
1617			if funcbody == nil {
1618				funv := r.ValueOf(func(int8,
1619
1620					complex64) {})
1621				ret = func(env *Env) r.Value { return funv }
1622
1623				break
1624			}
1625			ret = func(env *Env) r.Value {
1626
1627				env.MarkUsedByClosure()
1628				return r.ValueOf(func(arg0 int8,
1629
1630					arg1 complex64,
1631				) {
1632					env := newEnv4Func(env, nbind, nintbind, debugC)
1633
1634					*(*int8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
1635
1636					*(*complex64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
1637
1638					funcbody(env)
1639
1640					env.freeEnv4Func()
1641				})
1642			}
1643		}
1644	case r.Complex128:
1645		{
1646			if funcbody == nil {
1647				funv := r.ValueOf(func(int8,
1648
1649					complex128) {})
1650				ret = func(env *Env) r.Value { return funv }
1651
1652				break
1653			}
1654			ret = func(env *Env) r.Value {
1655
1656				env.MarkUsedByClosure()
1657				return r.ValueOf(func(arg0 int8,
1658
1659					arg1 complex128) {
1660					env := newEnv4Func(env, nbind, nintbind, debugC)
1661
1662					*(*int8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
1663
1664					*(*complex128)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
1665
1666					funcbody(env)
1667
1668					env.freeEnv4Func()
1669				})
1670			}
1671		}
1672	case r.String:
1673		{
1674			if funcbody == nil {
1675				funv := r.ValueOf(func(int8,
1676
1677					string) {})
1678				ret = func(env *Env) r.Value { return funv }
1679
1680				break
1681			}
1682			ret = func(env *Env) r.Value {
1683
1684				env.MarkUsedByClosure()
1685				return r.ValueOf(func(arg0 int8,
1686
1687					arg1 string) {
1688					env := newEnv4Func(env, nbind, nintbind, debugC)
1689
1690					*(*int8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
1691
1692					{
1693						place := r.New(TypeOfString).Elem()
1694						place.SetString(arg1,
1695						)
1696						env.Vals[indexes[1]] = place
1697					}
1698
1699					funcbody(env)
1700
1701					env.freeEnv4Func()
1702				})
1703			}
1704		}
1705	}
1706	return ret
1707}
1708func func2ret0Int16(m *funcMaker, indexes *[2]int, karg1 r.Kind, debugC *Comp) func(*Env) r.Value {
1709
1710	nbind := m.nbind
1711	nintbind := m.nintbind
1712	funcbody := m.funcbody
1713	var ret func(*Env) r.Value
1714	switch karg1 {
1715	case r.Bool:
1716
1717		{
1718			if funcbody == nil {
1719				funv := r.ValueOf(func(int16,
1720
1721					bool,
1722
1723				) {})
1724				ret = func(env *Env) r.Value { return funv }
1725
1726				break
1727			}
1728			ret = func(env *Env) r.Value {
1729
1730				env.MarkUsedByClosure()
1731				return r.ValueOf(func(arg0 int16,
1732
1733					arg1 bool,
1734
1735				) {
1736					env := newEnv4Func(env, nbind, nintbind, debugC)
1737
1738					*(*int16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
1739
1740					*(*bool)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
1741
1742					funcbody(env)
1743
1744					env.freeEnv4Func()
1745				})
1746			}
1747		}
1748	case r.Int:
1749
1750		{
1751			if funcbody == nil {
1752				funv := r.ValueOf(func(int16,
1753
1754					int,
1755
1756				) {})
1757				ret = func(env *Env) r.Value { return funv }
1758
1759				break
1760			}
1761			ret = func(env *Env) r.Value {
1762
1763				env.MarkUsedByClosure()
1764				return r.ValueOf(func(arg0 int16,
1765
1766					arg1 int,
1767
1768				) {
1769					env := newEnv4Func(env, nbind, nintbind, debugC)
1770
1771					*(*int16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
1772
1773					*(*int)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
1774
1775					funcbody(env)
1776
1777					env.freeEnv4Func()
1778				})
1779			}
1780		}
1781	case r.Int8:
1782
1783		{
1784			if funcbody == nil {
1785				funv := r.ValueOf(func(int16,
1786
1787					int8,
1788
1789				) {})
1790				ret = func(env *Env) r.Value { return funv }
1791
1792				break
1793			}
1794			ret = func(env *Env) r.Value {
1795
1796				env.MarkUsedByClosure()
1797				return r.ValueOf(func(arg0 int16,
1798
1799					arg1 int8,
1800
1801				) {
1802					env := newEnv4Func(env, nbind, nintbind, debugC)
1803
1804					*(*int16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
1805
1806					*(*int8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
1807
1808					funcbody(env)
1809
1810					env.freeEnv4Func()
1811				})
1812			}
1813		}
1814	case r.Int16:
1815		{
1816			if funcbody == nil {
1817				funv := r.ValueOf(func(int16,
1818
1819					int16,
1820
1821				) {})
1822				ret = func(env *Env) r.Value { return funv }
1823
1824				break
1825			}
1826			ret = func(env *Env) r.Value {
1827
1828				env.MarkUsedByClosure()
1829				return r.ValueOf(func(arg0 int16,
1830
1831					arg1 int16,
1832
1833				) {
1834					env := newEnv4Func(env, nbind, nintbind, debugC)
1835
1836					*(*int16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
1837
1838					*(*int16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
1839
1840					funcbody(env)
1841
1842					env.freeEnv4Func()
1843				})
1844			}
1845		}
1846	case r.Int32:
1847		{
1848			if funcbody == nil {
1849				funv := r.ValueOf(func(int16,
1850
1851					int32,
1852
1853				) {})
1854				ret = func(env *Env) r.Value { return funv }
1855
1856				break
1857			}
1858			ret = func(env *Env) r.Value {
1859
1860				env.MarkUsedByClosure()
1861				return r.ValueOf(func(arg0 int16,
1862
1863					arg1 int32,
1864
1865				) {
1866					env := newEnv4Func(env, nbind, nintbind, debugC)
1867
1868					*(*int16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
1869
1870					*(*int32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
1871
1872					funcbody(env)
1873
1874					env.freeEnv4Func()
1875				})
1876			}
1877		}
1878	case r.Int64:
1879		{
1880			if funcbody == nil {
1881				funv := r.ValueOf(func(int16,
1882
1883					int64,
1884				) {})
1885				ret = func(env *Env) r.Value { return funv }
1886
1887				break
1888			}
1889			ret = func(env *Env) r.Value {
1890
1891				env.MarkUsedByClosure()
1892				return r.ValueOf(func(arg0 int16,
1893
1894					arg1 int64,
1895
1896				) {
1897					env := newEnv4Func(env, nbind, nintbind, debugC)
1898
1899					*(*int16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
1900
1901					*(*int64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
1902
1903					funcbody(env)
1904
1905					env.freeEnv4Func()
1906				})
1907			}
1908		}
1909	case r.Uint:
1910		{
1911			if funcbody == nil {
1912				funv := r.ValueOf(func(int16,
1913
1914					uint) {})
1915				ret = func(env *Env) r.Value { return funv }
1916
1917				break
1918			}
1919			ret = func(env *Env) r.Value {
1920
1921				env.MarkUsedByClosure()
1922				return r.ValueOf(func(arg0 int16,
1923
1924					arg1 uint,
1925
1926				) {
1927					env := newEnv4Func(env, nbind, nintbind, debugC)
1928
1929					*(*int16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
1930
1931					*(*uint)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
1932
1933					funcbody(env)
1934
1935					env.freeEnv4Func()
1936				})
1937			}
1938		}
1939	case r.Uint8:
1940		{
1941			if funcbody == nil {
1942				funv := r.ValueOf(func(int16,
1943
1944					uint8) {})
1945				ret = func(env *Env) r.Value { return funv }
1946
1947				break
1948			}
1949			ret = func(env *Env) r.Value {
1950
1951				env.MarkUsedByClosure()
1952				return r.ValueOf(func(arg0 int16,
1953
1954					arg1 uint8,
1955
1956				) {
1957					env := newEnv4Func(env, nbind, nintbind, debugC)
1958
1959					*(*int16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
1960
1961					*(*uint8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
1962
1963					funcbody(env)
1964
1965					env.freeEnv4Func()
1966				})
1967			}
1968		}
1969	case r.Uint16:
1970		{
1971			if funcbody == nil {
1972				funv := r.ValueOf(func(int16,
1973
1974					uint16) {})
1975				ret = func(env *Env) r.Value { return funv }
1976
1977				break
1978			}
1979			ret = func(env *Env) r.Value {
1980
1981				env.MarkUsedByClosure()
1982				return r.ValueOf(func(arg0 int16,
1983
1984					arg1 uint16,
1985
1986				) {
1987					env := newEnv4Func(env, nbind, nintbind, debugC)
1988
1989					*(*int16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
1990
1991					*(*uint16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
1992
1993					funcbody(env)
1994
1995					env.freeEnv4Func()
1996				})
1997			}
1998		}
1999	case r.Uint32:
2000		{
2001			if funcbody == nil {
2002				funv := r.ValueOf(func(int16,
2003
2004					uint32) {})
2005				ret = func(env *Env) r.Value { return funv }
2006
2007				break
2008			}
2009			ret = func(env *Env) r.Value {
2010
2011				env.MarkUsedByClosure()
2012				return r.ValueOf(func(arg0 int16,
2013
2014					arg1 uint32,
2015
2016				) {
2017					env := newEnv4Func(env, nbind, nintbind, debugC)
2018
2019					*(*int16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
2020
2021					*(*uint32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
2022
2023					funcbody(env)
2024
2025					env.freeEnv4Func()
2026				})
2027			}
2028		}
2029	case r.Uint64:
2030		{
2031			if funcbody == nil {
2032				funv := r.ValueOf(func(int16,
2033
2034					uint64) {})
2035				ret = func(env *Env) r.Value { return funv }
2036
2037				break
2038			}
2039			ret = func(env *Env) r.Value {
2040
2041				env.MarkUsedByClosure()
2042				return r.ValueOf(func(arg0 int16,
2043
2044					arg1 uint64,
2045
2046				) {
2047					env := newEnv4Func(env, nbind, nintbind, debugC)
2048
2049					*(*int16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
2050
2051					env.Ints[indexes[1]] = arg1
2052
2053					funcbody(env)
2054
2055					env.freeEnv4Func()
2056				})
2057			}
2058		}
2059	case r.Uintptr:
2060		{
2061			if funcbody == nil {
2062				funv := r.ValueOf(func(int16,
2063
2064					uintptr) {})
2065				ret = func(env *Env) r.Value { return funv }
2066
2067				break
2068			}
2069			ret = func(env *Env) r.Value {
2070
2071				env.MarkUsedByClosure()
2072				return r.ValueOf(func(arg0 int16,
2073
2074					arg1 uintptr,
2075
2076				) {
2077					env := newEnv4Func(env, nbind, nintbind, debugC)
2078
2079					*(*int16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
2080
2081					*(*uintptr)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
2082
2083					funcbody(env)
2084
2085					env.freeEnv4Func()
2086				})
2087			}
2088		}
2089	case r.Float32:
2090		{
2091			if funcbody == nil {
2092				funv := r.ValueOf(func(int16,
2093
2094					float32) {})
2095				ret = func(env *Env) r.Value { return funv }
2096
2097				break
2098			}
2099			ret = func(env *Env) r.Value {
2100
2101				env.MarkUsedByClosure()
2102				return r.ValueOf(func(arg0 int16,
2103
2104					arg1 float32,
2105
2106				) {
2107					env := newEnv4Func(env, nbind, nintbind, debugC)
2108
2109					*(*int16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
2110
2111					*(*float32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
2112
2113					funcbody(env)
2114
2115					env.freeEnv4Func()
2116				})
2117			}
2118		}
2119	case r.Float64:
2120		{
2121			if funcbody == nil {
2122				funv := r.ValueOf(func(int16,
2123
2124					float64) {})
2125				ret = func(env *Env) r.Value { return funv }
2126
2127				break
2128			}
2129			ret = func(env *Env) r.Value {
2130
2131				env.MarkUsedByClosure()
2132				return r.ValueOf(func(arg0 int16,
2133
2134					arg1 float64,
2135
2136				) {
2137					env := newEnv4Func(env, nbind, nintbind, debugC)
2138
2139					*(*int16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
2140
2141					*(*float64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
2142
2143					funcbody(env)
2144
2145					env.freeEnv4Func()
2146				})
2147			}
2148		}
2149	case r.Complex64:
2150		{
2151			if funcbody == nil {
2152				funv := r.ValueOf(func(int16,
2153
2154					complex64) {})
2155				ret = func(env *Env) r.Value { return funv }
2156
2157				break
2158			}
2159			ret = func(env *Env) r.Value {
2160
2161				env.MarkUsedByClosure()
2162				return r.ValueOf(func(arg0 int16,
2163
2164					arg1 complex64,
2165				) {
2166					env := newEnv4Func(env, nbind, nintbind, debugC)
2167
2168					*(*int16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
2169
2170					*(*complex64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
2171
2172					funcbody(env)
2173
2174					env.freeEnv4Func()
2175				})
2176			}
2177		}
2178	case r.Complex128:
2179		{
2180			if funcbody == nil {
2181				funv := r.ValueOf(func(int16,
2182
2183					complex128) {})
2184				ret = func(env *Env) r.Value { return funv }
2185
2186				break
2187			}
2188			ret = func(env *Env) r.Value {
2189
2190				env.MarkUsedByClosure()
2191				return r.ValueOf(func(arg0 int16,
2192
2193					arg1 complex128) {
2194					env := newEnv4Func(env, nbind, nintbind, debugC)
2195
2196					*(*int16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
2197
2198					*(*complex128)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
2199
2200					funcbody(env)
2201
2202					env.freeEnv4Func()
2203				})
2204			}
2205		}
2206	case r.String:
2207		{
2208			if funcbody == nil {
2209				funv := r.ValueOf(func(int16,
2210
2211					string) {})
2212				ret = func(env *Env) r.Value { return funv }
2213
2214				break
2215			}
2216			ret = func(env *Env) r.Value {
2217
2218				env.MarkUsedByClosure()
2219				return r.ValueOf(func(arg0 int16,
2220
2221					arg1 string) {
2222					env := newEnv4Func(env, nbind, nintbind, debugC)
2223
2224					*(*int16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
2225
2226					{
2227						place := r.New(TypeOfString).Elem()
2228						place.SetString(arg1,
2229						)
2230						env.Vals[indexes[1]] = place
2231					}
2232
2233					funcbody(env)
2234
2235					env.freeEnv4Func()
2236				})
2237			}
2238		}
2239	}
2240	return ret
2241}
2242func func2ret0Int32(m *funcMaker, indexes *[2]int, karg1 r.Kind, debugC *Comp) func(*Env) r.Value {
2243
2244	nbind := m.nbind
2245	nintbind := m.nintbind
2246	funcbody := m.funcbody
2247	var ret func(*Env) r.Value
2248	switch karg1 {
2249	case r.Bool:
2250
2251		{
2252			if funcbody == nil {
2253				funv := r.ValueOf(func(int32,
2254
2255					bool,
2256
2257				) {})
2258				ret = func(env *Env) r.Value { return funv }
2259
2260				break
2261			}
2262			ret = func(env *Env) r.Value {
2263
2264				env.MarkUsedByClosure()
2265				return r.ValueOf(func(arg0 int32,
2266
2267					arg1 bool,
2268
2269				) {
2270					env := newEnv4Func(env, nbind, nintbind, debugC)
2271
2272					*(*int32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
2273
2274					*(*bool)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
2275
2276					funcbody(env)
2277
2278					env.freeEnv4Func()
2279				})
2280			}
2281		}
2282	case r.Int:
2283
2284		{
2285			if funcbody == nil {
2286				funv := r.ValueOf(func(int32,
2287
2288					int,
2289
2290				) {})
2291				ret = func(env *Env) r.Value { return funv }
2292
2293				break
2294			}
2295			ret = func(env *Env) r.Value {
2296
2297				env.MarkUsedByClosure()
2298				return r.ValueOf(func(arg0 int32,
2299
2300					arg1 int,
2301
2302				) {
2303					env := newEnv4Func(env, nbind, nintbind, debugC)
2304
2305					*(*int32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
2306
2307					*(*int)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
2308
2309					funcbody(env)
2310
2311					env.freeEnv4Func()
2312				})
2313			}
2314		}
2315	case r.Int8:
2316
2317		{
2318			if funcbody == nil {
2319				funv := r.ValueOf(func(int32,
2320
2321					int8,
2322
2323				) {})
2324				ret = func(env *Env) r.Value { return funv }
2325
2326				break
2327			}
2328			ret = func(env *Env) r.Value {
2329
2330				env.MarkUsedByClosure()
2331				return r.ValueOf(func(arg0 int32,
2332
2333					arg1 int8,
2334
2335				) {
2336					env := newEnv4Func(env, nbind, nintbind, debugC)
2337
2338					*(*int32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
2339
2340					*(*int8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
2341
2342					funcbody(env)
2343
2344					env.freeEnv4Func()
2345				})
2346			}
2347		}
2348	case r.Int16:
2349		{
2350			if funcbody == nil {
2351				funv := r.ValueOf(func(int32,
2352
2353					int16,
2354
2355				) {})
2356				ret = func(env *Env) r.Value { return funv }
2357
2358				break
2359			}
2360			ret = func(env *Env) r.Value {
2361
2362				env.MarkUsedByClosure()
2363				return r.ValueOf(func(arg0 int32,
2364
2365					arg1 int16,
2366
2367				) {
2368					env := newEnv4Func(env, nbind, nintbind, debugC)
2369
2370					*(*int32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
2371
2372					*(*int16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
2373
2374					funcbody(env)
2375
2376					env.freeEnv4Func()
2377				})
2378			}
2379		}
2380	case r.Int32:
2381		{
2382			if funcbody == nil {
2383				funv := r.ValueOf(func(int32,
2384
2385					int32,
2386
2387				) {})
2388				ret = func(env *Env) r.Value { return funv }
2389
2390				break
2391			}
2392			ret = func(env *Env) r.Value {
2393
2394				env.MarkUsedByClosure()
2395				return r.ValueOf(func(arg0 int32,
2396
2397					arg1 int32,
2398
2399				) {
2400					env := newEnv4Func(env, nbind, nintbind, debugC)
2401
2402					*(*int32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
2403
2404					*(*int32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
2405
2406					funcbody(env)
2407
2408					env.freeEnv4Func()
2409				})
2410			}
2411		}
2412	case r.Int64:
2413		{
2414			if funcbody == nil {
2415				funv := r.ValueOf(func(int32,
2416
2417					int64,
2418				) {})
2419				ret = func(env *Env) r.Value { return funv }
2420
2421				break
2422			}
2423			ret = func(env *Env) r.Value {
2424
2425				env.MarkUsedByClosure()
2426				return r.ValueOf(func(arg0 int32,
2427
2428					arg1 int64,
2429
2430				) {
2431					env := newEnv4Func(env, nbind, nintbind, debugC)
2432
2433					*(*int32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
2434
2435					*(*int64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
2436
2437					funcbody(env)
2438
2439					env.freeEnv4Func()
2440				})
2441			}
2442		}
2443	case r.Uint:
2444		{
2445			if funcbody == nil {
2446				funv := r.ValueOf(func(int32,
2447
2448					uint) {})
2449				ret = func(env *Env) r.Value { return funv }
2450
2451				break
2452			}
2453			ret = func(env *Env) r.Value {
2454
2455				env.MarkUsedByClosure()
2456				return r.ValueOf(func(arg0 int32,
2457
2458					arg1 uint,
2459
2460				) {
2461					env := newEnv4Func(env, nbind, nintbind, debugC)
2462
2463					*(*int32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
2464
2465					*(*uint)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
2466
2467					funcbody(env)
2468
2469					env.freeEnv4Func()
2470				})
2471			}
2472		}
2473	case r.Uint8:
2474		{
2475			if funcbody == nil {
2476				funv := r.ValueOf(func(int32,
2477
2478					uint8) {})
2479				ret = func(env *Env) r.Value { return funv }
2480
2481				break
2482			}
2483			ret = func(env *Env) r.Value {
2484
2485				env.MarkUsedByClosure()
2486				return r.ValueOf(func(arg0 int32,
2487
2488					arg1 uint8,
2489
2490				) {
2491					env := newEnv4Func(env, nbind, nintbind, debugC)
2492
2493					*(*int32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
2494
2495					*(*uint8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
2496
2497					funcbody(env)
2498
2499					env.freeEnv4Func()
2500				})
2501			}
2502		}
2503	case r.Uint16:
2504		{
2505			if funcbody == nil {
2506				funv := r.ValueOf(func(int32,
2507
2508					uint16) {})
2509				ret = func(env *Env) r.Value { return funv }
2510
2511				break
2512			}
2513			ret = func(env *Env) r.Value {
2514
2515				env.MarkUsedByClosure()
2516				return r.ValueOf(func(arg0 int32,
2517
2518					arg1 uint16,
2519
2520				) {
2521					env := newEnv4Func(env, nbind, nintbind, debugC)
2522
2523					*(*int32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
2524
2525					*(*uint16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
2526
2527					funcbody(env)
2528
2529					env.freeEnv4Func()
2530				})
2531			}
2532		}
2533	case r.Uint32:
2534		{
2535			if funcbody == nil {
2536				funv := r.ValueOf(func(int32,
2537
2538					uint32) {})
2539				ret = func(env *Env) r.Value { return funv }
2540
2541				break
2542			}
2543			ret = func(env *Env) r.Value {
2544
2545				env.MarkUsedByClosure()
2546				return r.ValueOf(func(arg0 int32,
2547
2548					arg1 uint32,
2549
2550				) {
2551					env := newEnv4Func(env, nbind, nintbind, debugC)
2552
2553					*(*int32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
2554
2555					*(*uint32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
2556
2557					funcbody(env)
2558
2559					env.freeEnv4Func()
2560				})
2561			}
2562		}
2563	case r.Uint64:
2564		{
2565			if funcbody == nil {
2566				funv := r.ValueOf(func(int32,
2567
2568					uint64) {})
2569				ret = func(env *Env) r.Value { return funv }
2570
2571				break
2572			}
2573			ret = func(env *Env) r.Value {
2574
2575				env.MarkUsedByClosure()
2576				return r.ValueOf(func(arg0 int32,
2577
2578					arg1 uint64,
2579
2580				) {
2581					env := newEnv4Func(env, nbind, nintbind, debugC)
2582
2583					*(*int32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
2584
2585					env.Ints[indexes[1]] = arg1
2586
2587					funcbody(env)
2588
2589					env.freeEnv4Func()
2590				})
2591			}
2592		}
2593	case r.Uintptr:
2594		{
2595			if funcbody == nil {
2596				funv := r.ValueOf(func(int32,
2597
2598					uintptr) {})
2599				ret = func(env *Env) r.Value { return funv }
2600
2601				break
2602			}
2603			ret = func(env *Env) r.Value {
2604
2605				env.MarkUsedByClosure()
2606				return r.ValueOf(func(arg0 int32,
2607
2608					arg1 uintptr,
2609
2610				) {
2611					env := newEnv4Func(env, nbind, nintbind, debugC)
2612
2613					*(*int32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
2614
2615					*(*uintptr)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
2616
2617					funcbody(env)
2618
2619					env.freeEnv4Func()
2620				})
2621			}
2622		}
2623	case r.Float32:
2624		{
2625			if funcbody == nil {
2626				funv := r.ValueOf(func(int32,
2627
2628					float32) {})
2629				ret = func(env *Env) r.Value { return funv }
2630
2631				break
2632			}
2633			ret = func(env *Env) r.Value {
2634
2635				env.MarkUsedByClosure()
2636				return r.ValueOf(func(arg0 int32,
2637
2638					arg1 float32,
2639
2640				) {
2641					env := newEnv4Func(env, nbind, nintbind, debugC)
2642
2643					*(*int32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
2644
2645					*(*float32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
2646
2647					funcbody(env)
2648
2649					env.freeEnv4Func()
2650				})
2651			}
2652		}
2653	case r.Float64:
2654		{
2655			if funcbody == nil {
2656				funv := r.ValueOf(func(int32,
2657
2658					float64) {})
2659				ret = func(env *Env) r.Value { return funv }
2660
2661				break
2662			}
2663			ret = func(env *Env) r.Value {
2664
2665				env.MarkUsedByClosure()
2666				return r.ValueOf(func(arg0 int32,
2667
2668					arg1 float64,
2669
2670				) {
2671					env := newEnv4Func(env, nbind, nintbind, debugC)
2672
2673					*(*int32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
2674
2675					*(*float64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
2676
2677					funcbody(env)
2678
2679					env.freeEnv4Func()
2680				})
2681			}
2682		}
2683	case r.Complex64:
2684		{
2685			if funcbody == nil {
2686				funv := r.ValueOf(func(int32,
2687
2688					complex64) {})
2689				ret = func(env *Env) r.Value { return funv }
2690
2691				break
2692			}
2693			ret = func(env *Env) r.Value {
2694
2695				env.MarkUsedByClosure()
2696				return r.ValueOf(func(arg0 int32,
2697
2698					arg1 complex64,
2699				) {
2700					env := newEnv4Func(env, nbind, nintbind, debugC)
2701
2702					*(*int32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
2703
2704					*(*complex64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
2705
2706					funcbody(env)
2707
2708					env.freeEnv4Func()
2709				})
2710			}
2711		}
2712	case r.Complex128:
2713		{
2714			if funcbody == nil {
2715				funv := r.ValueOf(func(int32,
2716
2717					complex128) {})
2718				ret = func(env *Env) r.Value { return funv }
2719
2720				break
2721			}
2722			ret = func(env *Env) r.Value {
2723
2724				env.MarkUsedByClosure()
2725				return r.ValueOf(func(arg0 int32,
2726
2727					arg1 complex128) {
2728					env := newEnv4Func(env, nbind, nintbind, debugC)
2729
2730					*(*int32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
2731
2732					*(*complex128)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
2733
2734					funcbody(env)
2735
2736					env.freeEnv4Func()
2737				})
2738			}
2739		}
2740	case r.String:
2741		{
2742			if funcbody == nil {
2743				funv := r.ValueOf(func(int32,
2744
2745					string) {})
2746				ret = func(env *Env) r.Value { return funv }
2747
2748				break
2749			}
2750			ret = func(env *Env) r.Value {
2751
2752				env.MarkUsedByClosure()
2753				return r.ValueOf(func(arg0 int32,
2754
2755					arg1 string) {
2756					env := newEnv4Func(env, nbind, nintbind, debugC)
2757
2758					*(*int32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
2759
2760					{
2761						place := r.New(TypeOfString).Elem()
2762						place.SetString(arg1,
2763						)
2764						env.Vals[indexes[1]] = place
2765					}
2766
2767					funcbody(env)
2768
2769					env.freeEnv4Func()
2770				})
2771			}
2772		}
2773	}
2774	return ret
2775}
2776func func2ret0Int64(m *funcMaker, indexes *[2]int, karg1 r.Kind, debugC *Comp) func(*Env) r.Value {
2777
2778	nbind := m.nbind
2779	nintbind := m.nintbind
2780	funcbody := m.funcbody
2781	var ret func(*Env) r.Value
2782	switch karg1 {
2783	case r.Bool:
2784
2785		{
2786			if funcbody == nil {
2787				funv := r.ValueOf(func(int64,
2788
2789					bool,
2790
2791				) {})
2792				ret = func(env *Env) r.Value { return funv }
2793
2794				break
2795			}
2796			ret = func(env *Env) r.Value {
2797
2798				env.MarkUsedByClosure()
2799				return r.ValueOf(func(arg0 int64,
2800
2801					arg1 bool,
2802
2803				) {
2804					env := newEnv4Func(env, nbind, nintbind, debugC)
2805
2806					*(*int64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
2807
2808					*(*bool)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
2809
2810					funcbody(env)
2811
2812					env.freeEnv4Func()
2813				})
2814			}
2815		}
2816	case r.Int:
2817
2818		{
2819			if funcbody == nil {
2820				funv := r.ValueOf(func(int64,
2821
2822					int,
2823
2824				) {})
2825				ret = func(env *Env) r.Value { return funv }
2826
2827				break
2828			}
2829			ret = func(env *Env) r.Value {
2830
2831				env.MarkUsedByClosure()
2832				return r.ValueOf(func(arg0 int64,
2833
2834					arg1 int,
2835
2836				) {
2837					env := newEnv4Func(env, nbind, nintbind, debugC)
2838
2839					*(*int64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
2840
2841					*(*int)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
2842
2843					funcbody(env)
2844
2845					env.freeEnv4Func()
2846				})
2847			}
2848		}
2849	case r.Int8:
2850
2851		{
2852			if funcbody == nil {
2853				funv := r.ValueOf(func(int64,
2854
2855					int8,
2856
2857				) {})
2858				ret = func(env *Env) r.Value { return funv }
2859
2860				break
2861			}
2862			ret = func(env *Env) r.Value {
2863
2864				env.MarkUsedByClosure()
2865				return r.ValueOf(func(arg0 int64,
2866
2867					arg1 int8,
2868
2869				) {
2870					env := newEnv4Func(env, nbind, nintbind, debugC)
2871
2872					*(*int64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
2873
2874					*(*int8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
2875
2876					funcbody(env)
2877
2878					env.freeEnv4Func()
2879				})
2880			}
2881		}
2882	case r.Int16:
2883		{
2884			if funcbody == nil {
2885				funv := r.ValueOf(func(int64,
2886
2887					int16,
2888
2889				) {})
2890				ret = func(env *Env) r.Value { return funv }
2891
2892				break
2893			}
2894			ret = func(env *Env) r.Value {
2895
2896				env.MarkUsedByClosure()
2897				return r.ValueOf(func(arg0 int64,
2898
2899					arg1 int16,
2900
2901				) {
2902					env := newEnv4Func(env, nbind, nintbind, debugC)
2903
2904					*(*int64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
2905
2906					*(*int16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
2907
2908					funcbody(env)
2909
2910					env.freeEnv4Func()
2911				})
2912			}
2913		}
2914	case r.Int32:
2915		{
2916			if funcbody == nil {
2917				funv := r.ValueOf(func(int64,
2918
2919					int32,
2920
2921				) {})
2922				ret = func(env *Env) r.Value { return funv }
2923
2924				break
2925			}
2926			ret = func(env *Env) r.Value {
2927
2928				env.MarkUsedByClosure()
2929				return r.ValueOf(func(arg0 int64,
2930
2931					arg1 int32,
2932
2933				) {
2934					env := newEnv4Func(env, nbind, nintbind, debugC)
2935
2936					*(*int64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
2937
2938					*(*int32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
2939
2940					funcbody(env)
2941
2942					env.freeEnv4Func()
2943				})
2944			}
2945		}
2946	case r.Int64:
2947		{
2948			if funcbody == nil {
2949				funv := r.ValueOf(func(int64,
2950
2951					int64,
2952				) {})
2953				ret = func(env *Env) r.Value { return funv }
2954
2955				break
2956			}
2957			ret = func(env *Env) r.Value {
2958
2959				env.MarkUsedByClosure()
2960				return r.ValueOf(func(arg0 int64,
2961
2962					arg1 int64,
2963
2964				) {
2965					env := newEnv4Func(env, nbind, nintbind, debugC)
2966
2967					*(*int64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
2968
2969					*(*int64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
2970
2971					funcbody(env)
2972
2973					env.freeEnv4Func()
2974				})
2975			}
2976		}
2977	case r.Uint:
2978		{
2979			if funcbody == nil {
2980				funv := r.ValueOf(func(int64,
2981
2982					uint) {})
2983				ret = func(env *Env) r.Value { return funv }
2984
2985				break
2986			}
2987			ret = func(env *Env) r.Value {
2988
2989				env.MarkUsedByClosure()
2990				return r.ValueOf(func(arg0 int64,
2991
2992					arg1 uint,
2993
2994				) {
2995					env := newEnv4Func(env, nbind, nintbind, debugC)
2996
2997					*(*int64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
2998
2999					*(*uint)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
3000
3001					funcbody(env)
3002
3003					env.freeEnv4Func()
3004				})
3005			}
3006		}
3007	case r.Uint8:
3008		{
3009			if funcbody == nil {
3010				funv := r.ValueOf(func(int64,
3011
3012					uint8) {})
3013				ret = func(env *Env) r.Value { return funv }
3014
3015				break
3016			}
3017			ret = func(env *Env) r.Value {
3018
3019				env.MarkUsedByClosure()
3020				return r.ValueOf(func(arg0 int64,
3021
3022					arg1 uint8,
3023
3024				) {
3025					env := newEnv4Func(env, nbind, nintbind, debugC)
3026
3027					*(*int64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
3028
3029					*(*uint8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
3030
3031					funcbody(env)
3032
3033					env.freeEnv4Func()
3034				})
3035			}
3036		}
3037	case r.Uint16:
3038		{
3039			if funcbody == nil {
3040				funv := r.ValueOf(func(int64,
3041
3042					uint16) {})
3043				ret = func(env *Env) r.Value { return funv }
3044
3045				break
3046			}
3047			ret = func(env *Env) r.Value {
3048
3049				env.MarkUsedByClosure()
3050				return r.ValueOf(func(arg0 int64,
3051
3052					arg1 uint16,
3053
3054				) {
3055					env := newEnv4Func(env, nbind, nintbind, debugC)
3056
3057					*(*int64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
3058
3059					*(*uint16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
3060
3061					funcbody(env)
3062
3063					env.freeEnv4Func()
3064				})
3065			}
3066		}
3067	case r.Uint32:
3068		{
3069			if funcbody == nil {
3070				funv := r.ValueOf(func(int64,
3071
3072					uint32) {})
3073				ret = func(env *Env) r.Value { return funv }
3074
3075				break
3076			}
3077			ret = func(env *Env) r.Value {
3078
3079				env.MarkUsedByClosure()
3080				return r.ValueOf(func(arg0 int64,
3081
3082					arg1 uint32,
3083
3084				) {
3085					env := newEnv4Func(env, nbind, nintbind, debugC)
3086
3087					*(*int64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
3088
3089					*(*uint32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
3090
3091					funcbody(env)
3092
3093					env.freeEnv4Func()
3094				})
3095			}
3096		}
3097	case r.Uint64:
3098		{
3099			if funcbody == nil {
3100				funv := r.ValueOf(func(int64,
3101
3102					uint64) {})
3103				ret = func(env *Env) r.Value { return funv }
3104
3105				break
3106			}
3107			ret = func(env *Env) r.Value {
3108
3109				env.MarkUsedByClosure()
3110				return r.ValueOf(func(arg0 int64,
3111
3112					arg1 uint64,
3113
3114				) {
3115					env := newEnv4Func(env, nbind, nintbind, debugC)
3116
3117					*(*int64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
3118
3119					env.Ints[indexes[1]] = arg1
3120
3121					funcbody(env)
3122
3123					env.freeEnv4Func()
3124				})
3125			}
3126		}
3127	case r.Uintptr:
3128		{
3129			if funcbody == nil {
3130				funv := r.ValueOf(func(int64,
3131
3132					uintptr) {})
3133				ret = func(env *Env) r.Value { return funv }
3134
3135				break
3136			}
3137			ret = func(env *Env) r.Value {
3138
3139				env.MarkUsedByClosure()
3140				return r.ValueOf(func(arg0 int64,
3141
3142					arg1 uintptr,
3143
3144				) {
3145					env := newEnv4Func(env, nbind, nintbind, debugC)
3146
3147					*(*int64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
3148
3149					*(*uintptr)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
3150
3151					funcbody(env)
3152
3153					env.freeEnv4Func()
3154				})
3155			}
3156		}
3157	case r.Float32:
3158		{
3159			if funcbody == nil {
3160				funv := r.ValueOf(func(int64,
3161
3162					float32) {})
3163				ret = func(env *Env) r.Value { return funv }
3164
3165				break
3166			}
3167			ret = func(env *Env) r.Value {
3168
3169				env.MarkUsedByClosure()
3170				return r.ValueOf(func(arg0 int64,
3171
3172					arg1 float32,
3173
3174				) {
3175					env := newEnv4Func(env, nbind, nintbind, debugC)
3176
3177					*(*int64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
3178
3179					*(*float32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
3180
3181					funcbody(env)
3182
3183					env.freeEnv4Func()
3184				})
3185			}
3186		}
3187	case r.Float64:
3188		{
3189			if funcbody == nil {
3190				funv := r.ValueOf(func(int64,
3191
3192					float64) {})
3193				ret = func(env *Env) r.Value { return funv }
3194
3195				break
3196			}
3197			ret = func(env *Env) r.Value {
3198
3199				env.MarkUsedByClosure()
3200				return r.ValueOf(func(arg0 int64,
3201
3202					arg1 float64,
3203
3204				) {
3205					env := newEnv4Func(env, nbind, nintbind, debugC)
3206
3207					*(*int64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
3208
3209					*(*float64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
3210
3211					funcbody(env)
3212
3213					env.freeEnv4Func()
3214				})
3215			}
3216		}
3217	case r.Complex64:
3218		{
3219			if funcbody == nil {
3220				funv := r.ValueOf(func(int64,
3221
3222					complex64) {})
3223				ret = func(env *Env) r.Value { return funv }
3224
3225				break
3226			}
3227			ret = func(env *Env) r.Value {
3228
3229				env.MarkUsedByClosure()
3230				return r.ValueOf(func(arg0 int64,
3231
3232					arg1 complex64,
3233				) {
3234					env := newEnv4Func(env, nbind, nintbind, debugC)
3235
3236					*(*int64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
3237
3238					*(*complex64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
3239
3240					funcbody(env)
3241
3242					env.freeEnv4Func()
3243				})
3244			}
3245		}
3246	case r.Complex128:
3247		{
3248			if funcbody == nil {
3249				funv := r.ValueOf(func(int64,
3250
3251					complex128) {})
3252				ret = func(env *Env) r.Value { return funv }
3253
3254				break
3255			}
3256			ret = func(env *Env) r.Value {
3257
3258				env.MarkUsedByClosure()
3259				return r.ValueOf(func(arg0 int64,
3260
3261					arg1 complex128) {
3262					env := newEnv4Func(env, nbind, nintbind, debugC)
3263
3264					*(*int64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
3265
3266					*(*complex128)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
3267
3268					funcbody(env)
3269
3270					env.freeEnv4Func()
3271				})
3272			}
3273		}
3274	case r.String:
3275		{
3276			if funcbody == nil {
3277				funv := r.ValueOf(func(int64,
3278
3279					string) {})
3280				ret = func(env *Env) r.Value { return funv }
3281
3282				break
3283			}
3284			ret = func(env *Env) r.Value {
3285
3286				env.MarkUsedByClosure()
3287				return r.ValueOf(func(arg0 int64,
3288
3289					arg1 string) {
3290					env := newEnv4Func(env, nbind, nintbind, debugC)
3291
3292					*(*int64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
3293
3294					{
3295						place := r.New(TypeOfString).Elem()
3296						place.SetString(arg1,
3297						)
3298						env.Vals[indexes[1]] = place
3299					}
3300
3301					funcbody(env)
3302
3303					env.freeEnv4Func()
3304				})
3305			}
3306		}
3307	}
3308	return ret
3309}
3310func func2ret0Uint(m *funcMaker, indexes *[2]int, karg1 r.Kind, debugC *Comp) func(*Env) r.Value {
3311
3312	nbind := m.nbind
3313	nintbind := m.nintbind
3314	funcbody := m.funcbody
3315	var ret func(*Env) r.Value
3316	switch karg1 {
3317	case r.Bool:
3318
3319		{
3320			if funcbody == nil {
3321				funv := r.ValueOf(func(uint,
3322
3323					bool,
3324
3325				) {})
3326				ret = func(env *Env) r.Value { return funv }
3327
3328				break
3329			}
3330			ret = func(env *Env) r.Value {
3331
3332				env.MarkUsedByClosure()
3333				return r.ValueOf(func(arg0 uint,
3334
3335					arg1 bool,
3336
3337				) {
3338					env := newEnv4Func(env, nbind, nintbind, debugC)
3339
3340					*(*uint)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
3341
3342					*(*bool)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
3343
3344					funcbody(env)
3345
3346					env.freeEnv4Func()
3347				})
3348			}
3349		}
3350	case r.Int:
3351
3352		{
3353			if funcbody == nil {
3354				funv := r.ValueOf(func(uint,
3355
3356					int,
3357
3358				) {})
3359				ret = func(env *Env) r.Value { return funv }
3360
3361				break
3362			}
3363			ret = func(env *Env) r.Value {
3364
3365				env.MarkUsedByClosure()
3366				return r.ValueOf(func(arg0 uint,
3367
3368					arg1 int,
3369
3370				) {
3371					env := newEnv4Func(env, nbind, nintbind, debugC)
3372
3373					*(*uint)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
3374
3375					*(*int)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
3376
3377					funcbody(env)
3378
3379					env.freeEnv4Func()
3380				})
3381			}
3382		}
3383	case r.Int8:
3384
3385		{
3386			if funcbody == nil {
3387				funv := r.ValueOf(func(uint,
3388
3389					int8,
3390
3391				) {})
3392				ret = func(env *Env) r.Value { return funv }
3393
3394				break
3395			}
3396			ret = func(env *Env) r.Value {
3397
3398				env.MarkUsedByClosure()
3399				return r.ValueOf(func(arg0 uint,
3400
3401					arg1 int8,
3402
3403				) {
3404					env := newEnv4Func(env, nbind, nintbind, debugC)
3405
3406					*(*uint)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
3407
3408					*(*int8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
3409
3410					funcbody(env)
3411
3412					env.freeEnv4Func()
3413				})
3414			}
3415		}
3416	case r.Int16:
3417		{
3418			if funcbody == nil {
3419				funv := r.ValueOf(func(uint,
3420
3421					int16,
3422
3423				) {})
3424				ret = func(env *Env) r.Value { return funv }
3425
3426				break
3427			}
3428			ret = func(env *Env) r.Value {
3429
3430				env.MarkUsedByClosure()
3431				return r.ValueOf(func(arg0 uint,
3432
3433					arg1 int16,
3434
3435				) {
3436					env := newEnv4Func(env, nbind, nintbind, debugC)
3437
3438					*(*uint)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
3439
3440					*(*int16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
3441
3442					funcbody(env)
3443
3444					env.freeEnv4Func()
3445				})
3446			}
3447		}
3448	case r.Int32:
3449		{
3450			if funcbody == nil {
3451				funv := r.ValueOf(func(uint,
3452
3453					int32,
3454
3455				) {})
3456				ret = func(env *Env) r.Value { return funv }
3457
3458				break
3459			}
3460			ret = func(env *Env) r.Value {
3461
3462				env.MarkUsedByClosure()
3463				return r.ValueOf(func(arg0 uint,
3464
3465					arg1 int32,
3466
3467				) {
3468					env := newEnv4Func(env, nbind, nintbind, debugC)
3469
3470					*(*uint)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
3471
3472					*(*int32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
3473
3474					funcbody(env)
3475
3476					env.freeEnv4Func()
3477				})
3478			}
3479		}
3480	case r.Int64:
3481		{
3482			if funcbody == nil {
3483				funv := r.ValueOf(func(uint,
3484
3485					int64,
3486				) {})
3487				ret = func(env *Env) r.Value { return funv }
3488
3489				break
3490			}
3491			ret = func(env *Env) r.Value {
3492
3493				env.MarkUsedByClosure()
3494				return r.ValueOf(func(arg0 uint,
3495
3496					arg1 int64,
3497
3498				) {
3499					env := newEnv4Func(env, nbind, nintbind, debugC)
3500
3501					*(*uint)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
3502
3503					*(*int64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
3504
3505					funcbody(env)
3506
3507					env.freeEnv4Func()
3508				})
3509			}
3510		}
3511	case r.Uint:
3512		{
3513			if funcbody == nil {
3514				funv := r.ValueOf(func(uint,
3515
3516					uint) {})
3517				ret = func(env *Env) r.Value { return funv }
3518
3519				break
3520			}
3521			ret = func(env *Env) r.Value {
3522
3523				env.MarkUsedByClosure()
3524				return r.ValueOf(func(arg0 uint,
3525
3526					arg1 uint,
3527
3528				) {
3529					env := newEnv4Func(env, nbind, nintbind, debugC)
3530
3531					*(*uint)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
3532
3533					*(*uint)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
3534
3535					funcbody(env)
3536
3537					env.freeEnv4Func()
3538				})
3539			}
3540		}
3541	case r.Uint8:
3542		{
3543			if funcbody == nil {
3544				funv := r.ValueOf(func(uint,
3545
3546					uint8) {})
3547				ret = func(env *Env) r.Value { return funv }
3548
3549				break
3550			}
3551			ret = func(env *Env) r.Value {
3552
3553				env.MarkUsedByClosure()
3554				return r.ValueOf(func(arg0 uint,
3555
3556					arg1 uint8,
3557
3558				) {
3559					env := newEnv4Func(env, nbind, nintbind, debugC)
3560
3561					*(*uint)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
3562
3563					*(*uint8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
3564
3565					funcbody(env)
3566
3567					env.freeEnv4Func()
3568				})
3569			}
3570		}
3571	case r.Uint16:
3572		{
3573			if funcbody == nil {
3574				funv := r.ValueOf(func(uint,
3575
3576					uint16) {})
3577				ret = func(env *Env) r.Value { return funv }
3578
3579				break
3580			}
3581			ret = func(env *Env) r.Value {
3582
3583				env.MarkUsedByClosure()
3584				return r.ValueOf(func(arg0 uint,
3585
3586					arg1 uint16,
3587
3588				) {
3589					env := newEnv4Func(env, nbind, nintbind, debugC)
3590
3591					*(*uint)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
3592
3593					*(*uint16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
3594
3595					funcbody(env)
3596
3597					env.freeEnv4Func()
3598				})
3599			}
3600		}
3601	case r.Uint32:
3602		{
3603			if funcbody == nil {
3604				funv := r.ValueOf(func(uint,
3605
3606					uint32) {})
3607				ret = func(env *Env) r.Value { return funv }
3608
3609				break
3610			}
3611			ret = func(env *Env) r.Value {
3612
3613				env.MarkUsedByClosure()
3614				return r.ValueOf(func(arg0 uint,
3615
3616					arg1 uint32,
3617
3618				) {
3619					env := newEnv4Func(env, nbind, nintbind, debugC)
3620
3621					*(*uint)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
3622
3623					*(*uint32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
3624
3625					funcbody(env)
3626
3627					env.freeEnv4Func()
3628				})
3629			}
3630		}
3631	case r.Uint64:
3632		{
3633			if funcbody == nil {
3634				funv := r.ValueOf(func(uint,
3635
3636					uint64) {})
3637				ret = func(env *Env) r.Value { return funv }
3638
3639				break
3640			}
3641			ret = func(env *Env) r.Value {
3642
3643				env.MarkUsedByClosure()
3644				return r.ValueOf(func(arg0 uint,
3645
3646					arg1 uint64,
3647
3648				) {
3649					env := newEnv4Func(env, nbind, nintbind, debugC)
3650
3651					*(*uint)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
3652
3653					env.Ints[indexes[1]] = arg1
3654
3655					funcbody(env)
3656
3657					env.freeEnv4Func()
3658				})
3659			}
3660		}
3661	case r.Uintptr:
3662		{
3663			if funcbody == nil {
3664				funv := r.ValueOf(func(uint,
3665
3666					uintptr) {})
3667				ret = func(env *Env) r.Value { return funv }
3668
3669				break
3670			}
3671			ret = func(env *Env) r.Value {
3672
3673				env.MarkUsedByClosure()
3674				return r.ValueOf(func(arg0 uint,
3675
3676					arg1 uintptr,
3677
3678				) {
3679					env := newEnv4Func(env, nbind, nintbind, debugC)
3680
3681					*(*uint)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
3682
3683					*(*uintptr)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
3684
3685					funcbody(env)
3686
3687					env.freeEnv4Func()
3688				})
3689			}
3690		}
3691	case r.Float32:
3692		{
3693			if funcbody == nil {
3694				funv := r.ValueOf(func(uint,
3695
3696					float32) {})
3697				ret = func(env *Env) r.Value { return funv }
3698
3699				break
3700			}
3701			ret = func(env *Env) r.Value {
3702
3703				env.MarkUsedByClosure()
3704				return r.ValueOf(func(arg0 uint,
3705
3706					arg1 float32,
3707
3708				) {
3709					env := newEnv4Func(env, nbind, nintbind, debugC)
3710
3711					*(*uint)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
3712
3713					*(*float32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
3714
3715					funcbody(env)
3716
3717					env.freeEnv4Func()
3718				})
3719			}
3720		}
3721	case r.Float64:
3722		{
3723			if funcbody == nil {
3724				funv := r.ValueOf(func(uint,
3725
3726					float64) {})
3727				ret = func(env *Env) r.Value { return funv }
3728
3729				break
3730			}
3731			ret = func(env *Env) r.Value {
3732
3733				env.MarkUsedByClosure()
3734				return r.ValueOf(func(arg0 uint,
3735
3736					arg1 float64,
3737
3738				) {
3739					env := newEnv4Func(env, nbind, nintbind, debugC)
3740
3741					*(*uint)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
3742
3743					*(*float64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
3744
3745					funcbody(env)
3746
3747					env.freeEnv4Func()
3748				})
3749			}
3750		}
3751	case r.Complex64:
3752		{
3753			if funcbody == nil {
3754				funv := r.ValueOf(func(uint,
3755
3756					complex64) {})
3757				ret = func(env *Env) r.Value { return funv }
3758
3759				break
3760			}
3761			ret = func(env *Env) r.Value {
3762
3763				env.MarkUsedByClosure()
3764				return r.ValueOf(func(arg0 uint,
3765
3766					arg1 complex64,
3767				) {
3768					env := newEnv4Func(env, nbind, nintbind, debugC)
3769
3770					*(*uint)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
3771
3772					*(*complex64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
3773
3774					funcbody(env)
3775
3776					env.freeEnv4Func()
3777				})
3778			}
3779		}
3780	case r.Complex128:
3781		{
3782			if funcbody == nil {
3783				funv := r.ValueOf(func(uint,
3784
3785					complex128) {})
3786				ret = func(env *Env) r.Value { return funv }
3787
3788				break
3789			}
3790			ret = func(env *Env) r.Value {
3791
3792				env.MarkUsedByClosure()
3793				return r.ValueOf(func(arg0 uint,
3794
3795					arg1 complex128) {
3796					env := newEnv4Func(env, nbind, nintbind, debugC)
3797
3798					*(*uint)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
3799
3800					*(*complex128)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
3801
3802					funcbody(env)
3803
3804					env.freeEnv4Func()
3805				})
3806			}
3807		}
3808	case r.String:
3809		{
3810			if funcbody == nil {
3811				funv := r.ValueOf(func(uint,
3812
3813					string) {})
3814				ret = func(env *Env) r.Value { return funv }
3815
3816				break
3817			}
3818			ret = func(env *Env) r.Value {
3819
3820				env.MarkUsedByClosure()
3821				return r.ValueOf(func(arg0 uint,
3822
3823					arg1 string) {
3824					env := newEnv4Func(env, nbind, nintbind, debugC)
3825
3826					*(*uint)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
3827
3828					{
3829						place := r.New(TypeOfString).Elem()
3830						place.SetString(arg1,
3831						)
3832						env.Vals[indexes[1]] = place
3833					}
3834
3835					funcbody(env)
3836
3837					env.freeEnv4Func()
3838				})
3839			}
3840		}
3841	}
3842	return ret
3843}
3844func func2ret0Uint8(m *funcMaker, indexes *[2]int, karg1 r.Kind, debugC *Comp) func(*Env) r.Value {
3845
3846	nbind := m.nbind
3847	nintbind := m.nintbind
3848	funcbody := m.funcbody
3849	var ret func(*Env) r.Value
3850	switch karg1 {
3851	case r.Bool:
3852
3853		{
3854			if funcbody == nil {
3855				funv := r.ValueOf(func(uint8,
3856
3857					bool,
3858
3859				) {})
3860				ret = func(env *Env) r.Value { return funv }
3861
3862				break
3863			}
3864			ret = func(env *Env) r.Value {
3865
3866				env.MarkUsedByClosure()
3867				return r.ValueOf(func(arg0 uint8,
3868
3869					arg1 bool,
3870
3871				) {
3872					env := newEnv4Func(env, nbind, nintbind, debugC)
3873
3874					*(*uint8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
3875
3876					*(*bool)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
3877
3878					funcbody(env)
3879
3880					env.freeEnv4Func()
3881				})
3882			}
3883		}
3884	case r.Int:
3885
3886		{
3887			if funcbody == nil {
3888				funv := r.ValueOf(func(uint8,
3889
3890					int,
3891
3892				) {})
3893				ret = func(env *Env) r.Value { return funv }
3894
3895				break
3896			}
3897			ret = func(env *Env) r.Value {
3898
3899				env.MarkUsedByClosure()
3900				return r.ValueOf(func(arg0 uint8,
3901
3902					arg1 int,
3903
3904				) {
3905					env := newEnv4Func(env, nbind, nintbind, debugC)
3906
3907					*(*uint8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
3908
3909					*(*int)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
3910
3911					funcbody(env)
3912
3913					env.freeEnv4Func()
3914				})
3915			}
3916		}
3917	case r.Int8:
3918
3919		{
3920			if funcbody == nil {
3921				funv := r.ValueOf(func(uint8,
3922
3923					int8,
3924
3925				) {})
3926				ret = func(env *Env) r.Value { return funv }
3927
3928				break
3929			}
3930			ret = func(env *Env) r.Value {
3931
3932				env.MarkUsedByClosure()
3933				return r.ValueOf(func(arg0 uint8,
3934
3935					arg1 int8,
3936
3937				) {
3938					env := newEnv4Func(env, nbind, nintbind, debugC)
3939
3940					*(*uint8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
3941
3942					*(*int8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
3943
3944					funcbody(env)
3945
3946					env.freeEnv4Func()
3947				})
3948			}
3949		}
3950	case r.Int16:
3951		{
3952			if funcbody == nil {
3953				funv := r.ValueOf(func(uint8,
3954
3955					int16,
3956
3957				) {})
3958				ret = func(env *Env) r.Value { return funv }
3959
3960				break
3961			}
3962			ret = func(env *Env) r.Value {
3963
3964				env.MarkUsedByClosure()
3965				return r.ValueOf(func(arg0 uint8,
3966
3967					arg1 int16,
3968
3969				) {
3970					env := newEnv4Func(env, nbind, nintbind, debugC)
3971
3972					*(*uint8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
3973
3974					*(*int16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
3975
3976					funcbody(env)
3977
3978					env.freeEnv4Func()
3979				})
3980			}
3981		}
3982	case r.Int32:
3983		{
3984			if funcbody == nil {
3985				funv := r.ValueOf(func(uint8,
3986
3987					int32,
3988
3989				) {})
3990				ret = func(env *Env) r.Value { return funv }
3991
3992				break
3993			}
3994			ret = func(env *Env) r.Value {
3995
3996				env.MarkUsedByClosure()
3997				return r.ValueOf(func(arg0 uint8,
3998
3999					arg1 int32,
4000
4001				) {
4002					env := newEnv4Func(env, nbind, nintbind, debugC)
4003
4004					*(*uint8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
4005
4006					*(*int32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
4007
4008					funcbody(env)
4009
4010					env.freeEnv4Func()
4011				})
4012			}
4013		}
4014	case r.Int64:
4015		{
4016			if funcbody == nil {
4017				funv := r.ValueOf(func(uint8,
4018
4019					int64,
4020				) {})
4021				ret = func(env *Env) r.Value { return funv }
4022
4023				break
4024			}
4025			ret = func(env *Env) r.Value {
4026
4027				env.MarkUsedByClosure()
4028				return r.ValueOf(func(arg0 uint8,
4029
4030					arg1 int64,
4031
4032				) {
4033					env := newEnv4Func(env, nbind, nintbind, debugC)
4034
4035					*(*uint8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
4036
4037					*(*int64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
4038
4039					funcbody(env)
4040
4041					env.freeEnv4Func()
4042				})
4043			}
4044		}
4045	case r.Uint:
4046		{
4047			if funcbody == nil {
4048				funv := r.ValueOf(func(uint8,
4049
4050					uint) {})
4051				ret = func(env *Env) r.Value { return funv }
4052
4053				break
4054			}
4055			ret = func(env *Env) r.Value {
4056
4057				env.MarkUsedByClosure()
4058				return r.ValueOf(func(arg0 uint8,
4059
4060					arg1 uint,
4061
4062				) {
4063					env := newEnv4Func(env, nbind, nintbind, debugC)
4064
4065					*(*uint8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
4066
4067					*(*uint)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
4068
4069					funcbody(env)
4070
4071					env.freeEnv4Func()
4072				})
4073			}
4074		}
4075	case r.Uint8:
4076		{
4077			if funcbody == nil {
4078				funv := r.ValueOf(func(uint8,
4079
4080					uint8) {})
4081				ret = func(env *Env) r.Value { return funv }
4082
4083				break
4084			}
4085			ret = func(env *Env) r.Value {
4086
4087				env.MarkUsedByClosure()
4088				return r.ValueOf(func(arg0 uint8,
4089
4090					arg1 uint8,
4091
4092				) {
4093					env := newEnv4Func(env, nbind, nintbind, debugC)
4094
4095					*(*uint8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
4096
4097					*(*uint8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
4098
4099					funcbody(env)
4100
4101					env.freeEnv4Func()
4102				})
4103			}
4104		}
4105	case r.Uint16:
4106		{
4107			if funcbody == nil {
4108				funv := r.ValueOf(func(uint8,
4109
4110					uint16) {})
4111				ret = func(env *Env) r.Value { return funv }
4112
4113				break
4114			}
4115			ret = func(env *Env) r.Value {
4116
4117				env.MarkUsedByClosure()
4118				return r.ValueOf(func(arg0 uint8,
4119
4120					arg1 uint16,
4121
4122				) {
4123					env := newEnv4Func(env, nbind, nintbind, debugC)
4124
4125					*(*uint8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
4126
4127					*(*uint16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
4128
4129					funcbody(env)
4130
4131					env.freeEnv4Func()
4132				})
4133			}
4134		}
4135	case r.Uint32:
4136		{
4137			if funcbody == nil {
4138				funv := r.ValueOf(func(uint8,
4139
4140					uint32) {})
4141				ret = func(env *Env) r.Value { return funv }
4142
4143				break
4144			}
4145			ret = func(env *Env) r.Value {
4146
4147				env.MarkUsedByClosure()
4148				return r.ValueOf(func(arg0 uint8,
4149
4150					arg1 uint32,
4151
4152				) {
4153					env := newEnv4Func(env, nbind, nintbind, debugC)
4154
4155					*(*uint8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
4156
4157					*(*uint32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
4158
4159					funcbody(env)
4160
4161					env.freeEnv4Func()
4162				})
4163			}
4164		}
4165	case r.Uint64:
4166		{
4167			if funcbody == nil {
4168				funv := r.ValueOf(func(uint8,
4169
4170					uint64) {})
4171				ret = func(env *Env) r.Value { return funv }
4172
4173				break
4174			}
4175			ret = func(env *Env) r.Value {
4176
4177				env.MarkUsedByClosure()
4178				return r.ValueOf(func(arg0 uint8,
4179
4180					arg1 uint64,
4181
4182				) {
4183					env := newEnv4Func(env, nbind, nintbind, debugC)
4184
4185					*(*uint8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
4186
4187					env.Ints[indexes[1]] = arg1
4188
4189					funcbody(env)
4190
4191					env.freeEnv4Func()
4192				})
4193			}
4194		}
4195	case r.Uintptr:
4196		{
4197			if funcbody == nil {
4198				funv := r.ValueOf(func(uint8,
4199
4200					uintptr) {})
4201				ret = func(env *Env) r.Value { return funv }
4202
4203				break
4204			}
4205			ret = func(env *Env) r.Value {
4206
4207				env.MarkUsedByClosure()
4208				return r.ValueOf(func(arg0 uint8,
4209
4210					arg1 uintptr,
4211
4212				) {
4213					env := newEnv4Func(env, nbind, nintbind, debugC)
4214
4215					*(*uint8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
4216
4217					*(*uintptr)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
4218
4219					funcbody(env)
4220
4221					env.freeEnv4Func()
4222				})
4223			}
4224		}
4225	case r.Float32:
4226		{
4227			if funcbody == nil {
4228				funv := r.ValueOf(func(uint8,
4229
4230					float32) {})
4231				ret = func(env *Env) r.Value { return funv }
4232
4233				break
4234			}
4235			ret = func(env *Env) r.Value {
4236
4237				env.MarkUsedByClosure()
4238				return r.ValueOf(func(arg0 uint8,
4239
4240					arg1 float32,
4241
4242				) {
4243					env := newEnv4Func(env, nbind, nintbind, debugC)
4244
4245					*(*uint8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
4246
4247					*(*float32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
4248
4249					funcbody(env)
4250
4251					env.freeEnv4Func()
4252				})
4253			}
4254		}
4255	case r.Float64:
4256		{
4257			if funcbody == nil {
4258				funv := r.ValueOf(func(uint8,
4259
4260					float64) {})
4261				ret = func(env *Env) r.Value { return funv }
4262
4263				break
4264			}
4265			ret = func(env *Env) r.Value {
4266
4267				env.MarkUsedByClosure()
4268				return r.ValueOf(func(arg0 uint8,
4269
4270					arg1 float64,
4271
4272				) {
4273					env := newEnv4Func(env, nbind, nintbind, debugC)
4274
4275					*(*uint8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
4276
4277					*(*float64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
4278
4279					funcbody(env)
4280
4281					env.freeEnv4Func()
4282				})
4283			}
4284		}
4285	case r.Complex64:
4286		{
4287			if funcbody == nil {
4288				funv := r.ValueOf(func(uint8,
4289
4290					complex64) {})
4291				ret = func(env *Env) r.Value { return funv }
4292
4293				break
4294			}
4295			ret = func(env *Env) r.Value {
4296
4297				env.MarkUsedByClosure()
4298				return r.ValueOf(func(arg0 uint8,
4299
4300					arg1 complex64,
4301				) {
4302					env := newEnv4Func(env, nbind, nintbind, debugC)
4303
4304					*(*uint8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
4305
4306					*(*complex64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
4307
4308					funcbody(env)
4309
4310					env.freeEnv4Func()
4311				})
4312			}
4313		}
4314	case r.Complex128:
4315		{
4316			if funcbody == nil {
4317				funv := r.ValueOf(func(uint8,
4318
4319					complex128) {})
4320				ret = func(env *Env) r.Value { return funv }
4321
4322				break
4323			}
4324			ret = func(env *Env) r.Value {
4325
4326				env.MarkUsedByClosure()
4327				return r.ValueOf(func(arg0 uint8,
4328
4329					arg1 complex128) {
4330					env := newEnv4Func(env, nbind, nintbind, debugC)
4331
4332					*(*uint8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
4333
4334					*(*complex128)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
4335
4336					funcbody(env)
4337
4338					env.freeEnv4Func()
4339				})
4340			}
4341		}
4342	case r.String:
4343		{
4344			if funcbody == nil {
4345				funv := r.ValueOf(func(uint8,
4346
4347					string) {})
4348				ret = func(env *Env) r.Value { return funv }
4349
4350				break
4351			}
4352			ret = func(env *Env) r.Value {
4353
4354				env.MarkUsedByClosure()
4355				return r.ValueOf(func(arg0 uint8,
4356
4357					arg1 string) {
4358					env := newEnv4Func(env, nbind, nintbind, debugC)
4359
4360					*(*uint8)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
4361
4362					{
4363						place := r.New(TypeOfString).Elem()
4364						place.SetString(arg1,
4365						)
4366						env.Vals[indexes[1]] = place
4367					}
4368
4369					funcbody(env)
4370
4371					env.freeEnv4Func()
4372				})
4373			}
4374		}
4375	}
4376	return ret
4377}
4378func func2ret0Uint16(m *funcMaker, indexes *[2]int, karg1 r.Kind, debugC *Comp) func(*Env) r.Value {
4379
4380	nbind := m.nbind
4381	nintbind := m.nintbind
4382	funcbody := m.funcbody
4383	var ret func(*Env) r.Value
4384	switch karg1 {
4385	case r.Bool:
4386
4387		{
4388			if funcbody == nil {
4389				funv := r.ValueOf(func(uint16,
4390
4391					bool,
4392
4393				) {})
4394				ret = func(env *Env) r.Value { return funv }
4395
4396				break
4397			}
4398			ret = func(env *Env) r.Value {
4399
4400				env.MarkUsedByClosure()
4401				return r.ValueOf(func(arg0 uint16,
4402
4403					arg1 bool,
4404
4405				) {
4406					env := newEnv4Func(env, nbind, nintbind, debugC)
4407
4408					*(*uint16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
4409
4410					*(*bool)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
4411
4412					funcbody(env)
4413
4414					env.freeEnv4Func()
4415				})
4416			}
4417		}
4418	case r.Int:
4419
4420		{
4421			if funcbody == nil {
4422				funv := r.ValueOf(func(uint16,
4423
4424					int,
4425
4426				) {})
4427				ret = func(env *Env) r.Value { return funv }
4428
4429				break
4430			}
4431			ret = func(env *Env) r.Value {
4432
4433				env.MarkUsedByClosure()
4434				return r.ValueOf(func(arg0 uint16,
4435
4436					arg1 int,
4437
4438				) {
4439					env := newEnv4Func(env, nbind, nintbind, debugC)
4440
4441					*(*uint16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
4442
4443					*(*int)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
4444
4445					funcbody(env)
4446
4447					env.freeEnv4Func()
4448				})
4449			}
4450		}
4451	case r.Int8:
4452
4453		{
4454			if funcbody == nil {
4455				funv := r.ValueOf(func(uint16,
4456
4457					int8,
4458
4459				) {})
4460				ret = func(env *Env) r.Value { return funv }
4461
4462				break
4463			}
4464			ret = func(env *Env) r.Value {
4465
4466				env.MarkUsedByClosure()
4467				return r.ValueOf(func(arg0 uint16,
4468
4469					arg1 int8,
4470
4471				) {
4472					env := newEnv4Func(env, nbind, nintbind, debugC)
4473
4474					*(*uint16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
4475
4476					*(*int8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
4477
4478					funcbody(env)
4479
4480					env.freeEnv4Func()
4481				})
4482			}
4483		}
4484	case r.Int16:
4485		{
4486			if funcbody == nil {
4487				funv := r.ValueOf(func(uint16,
4488
4489					int16,
4490
4491				) {})
4492				ret = func(env *Env) r.Value { return funv }
4493
4494				break
4495			}
4496			ret = func(env *Env) r.Value {
4497
4498				env.MarkUsedByClosure()
4499				return r.ValueOf(func(arg0 uint16,
4500
4501					arg1 int16,
4502
4503				) {
4504					env := newEnv4Func(env, nbind, nintbind, debugC)
4505
4506					*(*uint16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
4507
4508					*(*int16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
4509
4510					funcbody(env)
4511
4512					env.freeEnv4Func()
4513				})
4514			}
4515		}
4516	case r.Int32:
4517		{
4518			if funcbody == nil {
4519				funv := r.ValueOf(func(uint16,
4520
4521					int32,
4522
4523				) {})
4524				ret = func(env *Env) r.Value { return funv }
4525
4526				break
4527			}
4528			ret = func(env *Env) r.Value {
4529
4530				env.MarkUsedByClosure()
4531				return r.ValueOf(func(arg0 uint16,
4532
4533					arg1 int32,
4534
4535				) {
4536					env := newEnv4Func(env, nbind, nintbind, debugC)
4537
4538					*(*uint16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
4539
4540					*(*int32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
4541
4542					funcbody(env)
4543
4544					env.freeEnv4Func()
4545				})
4546			}
4547		}
4548	case r.Int64:
4549		{
4550			if funcbody == nil {
4551				funv := r.ValueOf(func(uint16,
4552
4553					int64,
4554				) {})
4555				ret = func(env *Env) r.Value { return funv }
4556
4557				break
4558			}
4559			ret = func(env *Env) r.Value {
4560
4561				env.MarkUsedByClosure()
4562				return r.ValueOf(func(arg0 uint16,
4563
4564					arg1 int64,
4565
4566				) {
4567					env := newEnv4Func(env, nbind, nintbind, debugC)
4568
4569					*(*uint16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
4570
4571					*(*int64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
4572
4573					funcbody(env)
4574
4575					env.freeEnv4Func()
4576				})
4577			}
4578		}
4579	case r.Uint:
4580		{
4581			if funcbody == nil {
4582				funv := r.ValueOf(func(uint16,
4583
4584					uint) {})
4585				ret = func(env *Env) r.Value { return funv }
4586
4587				break
4588			}
4589			ret = func(env *Env) r.Value {
4590
4591				env.MarkUsedByClosure()
4592				return r.ValueOf(func(arg0 uint16,
4593
4594					arg1 uint,
4595
4596				) {
4597					env := newEnv4Func(env, nbind, nintbind, debugC)
4598
4599					*(*uint16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
4600
4601					*(*uint)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
4602
4603					funcbody(env)
4604
4605					env.freeEnv4Func()
4606				})
4607			}
4608		}
4609	case r.Uint8:
4610		{
4611			if funcbody == nil {
4612				funv := r.ValueOf(func(uint16,
4613
4614					uint8) {})
4615				ret = func(env *Env) r.Value { return funv }
4616
4617				break
4618			}
4619			ret = func(env *Env) r.Value {
4620
4621				env.MarkUsedByClosure()
4622				return r.ValueOf(func(arg0 uint16,
4623
4624					arg1 uint8,
4625
4626				) {
4627					env := newEnv4Func(env, nbind, nintbind, debugC)
4628
4629					*(*uint16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
4630
4631					*(*uint8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
4632
4633					funcbody(env)
4634
4635					env.freeEnv4Func()
4636				})
4637			}
4638		}
4639	case r.Uint16:
4640		{
4641			if funcbody == nil {
4642				funv := r.ValueOf(func(uint16,
4643
4644					uint16) {})
4645				ret = func(env *Env) r.Value { return funv }
4646
4647				break
4648			}
4649			ret = func(env *Env) r.Value {
4650
4651				env.MarkUsedByClosure()
4652				return r.ValueOf(func(arg0 uint16,
4653
4654					arg1 uint16,
4655
4656				) {
4657					env := newEnv4Func(env, nbind, nintbind, debugC)
4658
4659					*(*uint16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
4660
4661					*(*uint16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
4662
4663					funcbody(env)
4664
4665					env.freeEnv4Func()
4666				})
4667			}
4668		}
4669	case r.Uint32:
4670		{
4671			if funcbody == nil {
4672				funv := r.ValueOf(func(uint16,
4673
4674					uint32) {})
4675				ret = func(env *Env) r.Value { return funv }
4676
4677				break
4678			}
4679			ret = func(env *Env) r.Value {
4680
4681				env.MarkUsedByClosure()
4682				return r.ValueOf(func(arg0 uint16,
4683
4684					arg1 uint32,
4685
4686				) {
4687					env := newEnv4Func(env, nbind, nintbind, debugC)
4688
4689					*(*uint16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
4690
4691					*(*uint32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
4692
4693					funcbody(env)
4694
4695					env.freeEnv4Func()
4696				})
4697			}
4698		}
4699	case r.Uint64:
4700		{
4701			if funcbody == nil {
4702				funv := r.ValueOf(func(uint16,
4703
4704					uint64) {})
4705				ret = func(env *Env) r.Value { return funv }
4706
4707				break
4708			}
4709			ret = func(env *Env) r.Value {
4710
4711				env.MarkUsedByClosure()
4712				return r.ValueOf(func(arg0 uint16,
4713
4714					arg1 uint64,
4715
4716				) {
4717					env := newEnv4Func(env, nbind, nintbind, debugC)
4718
4719					*(*uint16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
4720
4721					env.Ints[indexes[1]] = arg1
4722
4723					funcbody(env)
4724
4725					env.freeEnv4Func()
4726				})
4727			}
4728		}
4729	case r.Uintptr:
4730		{
4731			if funcbody == nil {
4732				funv := r.ValueOf(func(uint16,
4733
4734					uintptr) {})
4735				ret = func(env *Env) r.Value { return funv }
4736
4737				break
4738			}
4739			ret = func(env *Env) r.Value {
4740
4741				env.MarkUsedByClosure()
4742				return r.ValueOf(func(arg0 uint16,
4743
4744					arg1 uintptr,
4745
4746				) {
4747					env := newEnv4Func(env, nbind, nintbind, debugC)
4748
4749					*(*uint16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
4750
4751					*(*uintptr)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
4752
4753					funcbody(env)
4754
4755					env.freeEnv4Func()
4756				})
4757			}
4758		}
4759	case r.Float32:
4760		{
4761			if funcbody == nil {
4762				funv := r.ValueOf(func(uint16,
4763
4764					float32) {})
4765				ret = func(env *Env) r.Value { return funv }
4766
4767				break
4768			}
4769			ret = func(env *Env) r.Value {
4770
4771				env.MarkUsedByClosure()
4772				return r.ValueOf(func(arg0 uint16,
4773
4774					arg1 float32,
4775
4776				) {
4777					env := newEnv4Func(env, nbind, nintbind, debugC)
4778
4779					*(*uint16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
4780
4781					*(*float32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
4782
4783					funcbody(env)
4784
4785					env.freeEnv4Func()
4786				})
4787			}
4788		}
4789	case r.Float64:
4790		{
4791			if funcbody == nil {
4792				funv := r.ValueOf(func(uint16,
4793
4794					float64) {})
4795				ret = func(env *Env) r.Value { return funv }
4796
4797				break
4798			}
4799			ret = func(env *Env) r.Value {
4800
4801				env.MarkUsedByClosure()
4802				return r.ValueOf(func(arg0 uint16,
4803
4804					arg1 float64,
4805
4806				) {
4807					env := newEnv4Func(env, nbind, nintbind, debugC)
4808
4809					*(*uint16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
4810
4811					*(*float64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
4812
4813					funcbody(env)
4814
4815					env.freeEnv4Func()
4816				})
4817			}
4818		}
4819	case r.Complex64:
4820		{
4821			if funcbody == nil {
4822				funv := r.ValueOf(func(uint16,
4823
4824					complex64) {})
4825				ret = func(env *Env) r.Value { return funv }
4826
4827				break
4828			}
4829			ret = func(env *Env) r.Value {
4830
4831				env.MarkUsedByClosure()
4832				return r.ValueOf(func(arg0 uint16,
4833
4834					arg1 complex64,
4835				) {
4836					env := newEnv4Func(env, nbind, nintbind, debugC)
4837
4838					*(*uint16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
4839
4840					*(*complex64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
4841
4842					funcbody(env)
4843
4844					env.freeEnv4Func()
4845				})
4846			}
4847		}
4848	case r.Complex128:
4849		{
4850			if funcbody == nil {
4851				funv := r.ValueOf(func(uint16,
4852
4853					complex128) {})
4854				ret = func(env *Env) r.Value { return funv }
4855
4856				break
4857			}
4858			ret = func(env *Env) r.Value {
4859
4860				env.MarkUsedByClosure()
4861				return r.ValueOf(func(arg0 uint16,
4862
4863					arg1 complex128) {
4864					env := newEnv4Func(env, nbind, nintbind, debugC)
4865
4866					*(*uint16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
4867
4868					*(*complex128)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
4869
4870					funcbody(env)
4871
4872					env.freeEnv4Func()
4873				})
4874			}
4875		}
4876	case r.String:
4877		{
4878			if funcbody == nil {
4879				funv := r.ValueOf(func(uint16,
4880
4881					string) {})
4882				ret = func(env *Env) r.Value { return funv }
4883
4884				break
4885			}
4886			ret = func(env *Env) r.Value {
4887
4888				env.MarkUsedByClosure()
4889				return r.ValueOf(func(arg0 uint16,
4890
4891					arg1 string) {
4892					env := newEnv4Func(env, nbind, nintbind, debugC)
4893
4894					*(*uint16)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
4895
4896					{
4897						place := r.New(TypeOfString).Elem()
4898						place.SetString(arg1,
4899						)
4900						env.Vals[indexes[1]] = place
4901					}
4902
4903					funcbody(env)
4904
4905					env.freeEnv4Func()
4906				})
4907			}
4908		}
4909	}
4910	return ret
4911}
4912func func2ret0Uint32(m *funcMaker, indexes *[2]int, karg1 r.Kind, debugC *Comp) func(*Env) r.Value {
4913
4914	nbind := m.nbind
4915	nintbind := m.nintbind
4916	funcbody := m.funcbody
4917	var ret func(*Env) r.Value
4918	switch karg1 {
4919	case r.Bool:
4920
4921		{
4922			if funcbody == nil {
4923				funv := r.ValueOf(func(uint32,
4924
4925					bool,
4926
4927				) {})
4928				ret = func(env *Env) r.Value { return funv }
4929
4930				break
4931			}
4932			ret = func(env *Env) r.Value {
4933
4934				env.MarkUsedByClosure()
4935				return r.ValueOf(func(arg0 uint32,
4936
4937					arg1 bool,
4938
4939				) {
4940					env := newEnv4Func(env, nbind, nintbind, debugC)
4941
4942					*(*uint32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
4943
4944					*(*bool)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
4945
4946					funcbody(env)
4947
4948					env.freeEnv4Func()
4949				})
4950			}
4951		}
4952	case r.Int:
4953
4954		{
4955			if funcbody == nil {
4956				funv := r.ValueOf(func(uint32,
4957
4958					int,
4959
4960				) {})
4961				ret = func(env *Env) r.Value { return funv }
4962
4963				break
4964			}
4965			ret = func(env *Env) r.Value {
4966
4967				env.MarkUsedByClosure()
4968				return r.ValueOf(func(arg0 uint32,
4969
4970					arg1 int,
4971
4972				) {
4973					env := newEnv4Func(env, nbind, nintbind, debugC)
4974
4975					*(*uint32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
4976
4977					*(*int)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
4978
4979					funcbody(env)
4980
4981					env.freeEnv4Func()
4982				})
4983			}
4984		}
4985	case r.Int8:
4986
4987		{
4988			if funcbody == nil {
4989				funv := r.ValueOf(func(uint32,
4990
4991					int8,
4992
4993				) {})
4994				ret = func(env *Env) r.Value { return funv }
4995
4996				break
4997			}
4998			ret = func(env *Env) r.Value {
4999
5000				env.MarkUsedByClosure()
5001				return r.ValueOf(func(arg0 uint32,
5002
5003					arg1 int8,
5004
5005				) {
5006					env := newEnv4Func(env, nbind, nintbind, debugC)
5007
5008					*(*uint32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
5009
5010					*(*int8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
5011
5012					funcbody(env)
5013
5014					env.freeEnv4Func()
5015				})
5016			}
5017		}
5018	case r.Int16:
5019		{
5020			if funcbody == nil {
5021				funv := r.ValueOf(func(uint32,
5022
5023					int16,
5024
5025				) {})
5026				ret = func(env *Env) r.Value { return funv }
5027
5028				break
5029			}
5030			ret = func(env *Env) r.Value {
5031
5032				env.MarkUsedByClosure()
5033				return r.ValueOf(func(arg0 uint32,
5034
5035					arg1 int16,
5036
5037				) {
5038					env := newEnv4Func(env, nbind, nintbind, debugC)
5039
5040					*(*uint32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
5041
5042					*(*int16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
5043
5044					funcbody(env)
5045
5046					env.freeEnv4Func()
5047				})
5048			}
5049		}
5050	case r.Int32:
5051		{
5052			if funcbody == nil {
5053				funv := r.ValueOf(func(uint32,
5054
5055					int32,
5056
5057				) {})
5058				ret = func(env *Env) r.Value { return funv }
5059
5060				break
5061			}
5062			ret = func(env *Env) r.Value {
5063
5064				env.MarkUsedByClosure()
5065				return r.ValueOf(func(arg0 uint32,
5066
5067					arg1 int32,
5068
5069				) {
5070					env := newEnv4Func(env, nbind, nintbind, debugC)
5071
5072					*(*uint32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
5073
5074					*(*int32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
5075
5076					funcbody(env)
5077
5078					env.freeEnv4Func()
5079				})
5080			}
5081		}
5082	case r.Int64:
5083		{
5084			if funcbody == nil {
5085				funv := r.ValueOf(func(uint32,
5086
5087					int64,
5088				) {})
5089				ret = func(env *Env) r.Value { return funv }
5090
5091				break
5092			}
5093			ret = func(env *Env) r.Value {
5094
5095				env.MarkUsedByClosure()
5096				return r.ValueOf(func(arg0 uint32,
5097
5098					arg1 int64,
5099
5100				) {
5101					env := newEnv4Func(env, nbind, nintbind, debugC)
5102
5103					*(*uint32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
5104
5105					*(*int64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
5106
5107					funcbody(env)
5108
5109					env.freeEnv4Func()
5110				})
5111			}
5112		}
5113	case r.Uint:
5114		{
5115			if funcbody == nil {
5116				funv := r.ValueOf(func(uint32,
5117
5118					uint) {})
5119				ret = func(env *Env) r.Value { return funv }
5120
5121				break
5122			}
5123			ret = func(env *Env) r.Value {
5124
5125				env.MarkUsedByClosure()
5126				return r.ValueOf(func(arg0 uint32,
5127
5128					arg1 uint,
5129
5130				) {
5131					env := newEnv4Func(env, nbind, nintbind, debugC)
5132
5133					*(*uint32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
5134
5135					*(*uint)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
5136
5137					funcbody(env)
5138
5139					env.freeEnv4Func()
5140				})
5141			}
5142		}
5143	case r.Uint8:
5144		{
5145			if funcbody == nil {
5146				funv := r.ValueOf(func(uint32,
5147
5148					uint8) {})
5149				ret = func(env *Env) r.Value { return funv }
5150
5151				break
5152			}
5153			ret = func(env *Env) r.Value {
5154
5155				env.MarkUsedByClosure()
5156				return r.ValueOf(func(arg0 uint32,
5157
5158					arg1 uint8,
5159
5160				) {
5161					env := newEnv4Func(env, nbind, nintbind, debugC)
5162
5163					*(*uint32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
5164
5165					*(*uint8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
5166
5167					funcbody(env)
5168
5169					env.freeEnv4Func()
5170				})
5171			}
5172		}
5173	case r.Uint16:
5174		{
5175			if funcbody == nil {
5176				funv := r.ValueOf(func(uint32,
5177
5178					uint16) {})
5179				ret = func(env *Env) r.Value { return funv }
5180
5181				break
5182			}
5183			ret = func(env *Env) r.Value {
5184
5185				env.MarkUsedByClosure()
5186				return r.ValueOf(func(arg0 uint32,
5187
5188					arg1 uint16,
5189
5190				) {
5191					env := newEnv4Func(env, nbind, nintbind, debugC)
5192
5193					*(*uint32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
5194
5195					*(*uint16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
5196
5197					funcbody(env)
5198
5199					env.freeEnv4Func()
5200				})
5201			}
5202		}
5203	case r.Uint32:
5204		{
5205			if funcbody == nil {
5206				funv := r.ValueOf(func(uint32,
5207
5208					uint32) {})
5209				ret = func(env *Env) r.Value { return funv }
5210
5211				break
5212			}
5213			ret = func(env *Env) r.Value {
5214
5215				env.MarkUsedByClosure()
5216				return r.ValueOf(func(arg0 uint32,
5217
5218					arg1 uint32,
5219
5220				) {
5221					env := newEnv4Func(env, nbind, nintbind, debugC)
5222
5223					*(*uint32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
5224
5225					*(*uint32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
5226
5227					funcbody(env)
5228
5229					env.freeEnv4Func()
5230				})
5231			}
5232		}
5233	case r.Uint64:
5234		{
5235			if funcbody == nil {
5236				funv := r.ValueOf(func(uint32,
5237
5238					uint64) {})
5239				ret = func(env *Env) r.Value { return funv }
5240
5241				break
5242			}
5243			ret = func(env *Env) r.Value {
5244
5245				env.MarkUsedByClosure()
5246				return r.ValueOf(func(arg0 uint32,
5247
5248					arg1 uint64,
5249
5250				) {
5251					env := newEnv4Func(env, nbind, nintbind, debugC)
5252
5253					*(*uint32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
5254
5255					env.Ints[indexes[1]] = arg1
5256
5257					funcbody(env)
5258
5259					env.freeEnv4Func()
5260				})
5261			}
5262		}
5263	case r.Uintptr:
5264		{
5265			if funcbody == nil {
5266				funv := r.ValueOf(func(uint32,
5267
5268					uintptr) {})
5269				ret = func(env *Env) r.Value { return funv }
5270
5271				break
5272			}
5273			ret = func(env *Env) r.Value {
5274
5275				env.MarkUsedByClosure()
5276				return r.ValueOf(func(arg0 uint32,
5277
5278					arg1 uintptr,
5279
5280				) {
5281					env := newEnv4Func(env, nbind, nintbind, debugC)
5282
5283					*(*uint32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
5284
5285					*(*uintptr)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
5286
5287					funcbody(env)
5288
5289					env.freeEnv4Func()
5290				})
5291			}
5292		}
5293	case r.Float32:
5294		{
5295			if funcbody == nil {
5296				funv := r.ValueOf(func(uint32,
5297
5298					float32) {})
5299				ret = func(env *Env) r.Value { return funv }
5300
5301				break
5302			}
5303			ret = func(env *Env) r.Value {
5304
5305				env.MarkUsedByClosure()
5306				return r.ValueOf(func(arg0 uint32,
5307
5308					arg1 float32,
5309
5310				) {
5311					env := newEnv4Func(env, nbind, nintbind, debugC)
5312
5313					*(*uint32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
5314
5315					*(*float32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
5316
5317					funcbody(env)
5318
5319					env.freeEnv4Func()
5320				})
5321			}
5322		}
5323	case r.Float64:
5324		{
5325			if funcbody == nil {
5326				funv := r.ValueOf(func(uint32,
5327
5328					float64) {})
5329				ret = func(env *Env) r.Value { return funv }
5330
5331				break
5332			}
5333			ret = func(env *Env) r.Value {
5334
5335				env.MarkUsedByClosure()
5336				return r.ValueOf(func(arg0 uint32,
5337
5338					arg1 float64,
5339
5340				) {
5341					env := newEnv4Func(env, nbind, nintbind, debugC)
5342
5343					*(*uint32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
5344
5345					*(*float64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
5346
5347					funcbody(env)
5348
5349					env.freeEnv4Func()
5350				})
5351			}
5352		}
5353	case r.Complex64:
5354		{
5355			if funcbody == nil {
5356				funv := r.ValueOf(func(uint32,
5357
5358					complex64) {})
5359				ret = func(env *Env) r.Value { return funv }
5360
5361				break
5362			}
5363			ret = func(env *Env) r.Value {
5364
5365				env.MarkUsedByClosure()
5366				return r.ValueOf(func(arg0 uint32,
5367
5368					arg1 complex64,
5369				) {
5370					env := newEnv4Func(env, nbind, nintbind, debugC)
5371
5372					*(*uint32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
5373
5374					*(*complex64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
5375
5376					funcbody(env)
5377
5378					env.freeEnv4Func()
5379				})
5380			}
5381		}
5382	case r.Complex128:
5383		{
5384			if funcbody == nil {
5385				funv := r.ValueOf(func(uint32,
5386
5387					complex128) {})
5388				ret = func(env *Env) r.Value { return funv }
5389
5390				break
5391			}
5392			ret = func(env *Env) r.Value {
5393
5394				env.MarkUsedByClosure()
5395				return r.ValueOf(func(arg0 uint32,
5396
5397					arg1 complex128) {
5398					env := newEnv4Func(env, nbind, nintbind, debugC)
5399
5400					*(*uint32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
5401
5402					*(*complex128)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
5403
5404					funcbody(env)
5405
5406					env.freeEnv4Func()
5407				})
5408			}
5409		}
5410	case r.String:
5411		{
5412			if funcbody == nil {
5413				funv := r.ValueOf(func(uint32,
5414
5415					string) {})
5416				ret = func(env *Env) r.Value { return funv }
5417
5418				break
5419			}
5420			ret = func(env *Env) r.Value {
5421
5422				env.MarkUsedByClosure()
5423				return r.ValueOf(func(arg0 uint32,
5424
5425					arg1 string) {
5426					env := newEnv4Func(env, nbind, nintbind, debugC)
5427
5428					*(*uint32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
5429
5430					{
5431						place := r.New(TypeOfString).Elem()
5432						place.SetString(arg1,
5433						)
5434						env.Vals[indexes[1]] = place
5435					}
5436
5437					funcbody(env)
5438
5439					env.freeEnv4Func()
5440				})
5441			}
5442		}
5443	}
5444	return ret
5445}
5446func func2ret0Uint64(m *funcMaker, indexes *[2]int, karg1 r.Kind, debugC *Comp) func(*Env) r.Value {
5447
5448	nbind := m.nbind
5449	nintbind := m.nintbind
5450	funcbody := m.funcbody
5451	var ret func(*Env) r.Value
5452	switch karg1 {
5453	case r.Bool:
5454
5455		{
5456			if funcbody == nil {
5457				funv := r.ValueOf(func(uint64,
5458
5459					bool,
5460
5461				) {})
5462				ret = func(env *Env) r.Value { return funv }
5463
5464				break
5465			}
5466			ret = func(env *Env) r.Value {
5467
5468				env.MarkUsedByClosure()
5469				return r.ValueOf(func(arg0 uint64,
5470
5471					arg1 bool,
5472
5473				) {
5474					env := newEnv4Func(env, nbind, nintbind, debugC)
5475					env.Ints[indexes[0]] = arg0
5476
5477					*(*bool)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
5478
5479					funcbody(env)
5480
5481					env.freeEnv4Func()
5482				})
5483			}
5484		}
5485	case r.Int:
5486
5487		{
5488			if funcbody == nil {
5489				funv := r.ValueOf(func(uint64,
5490
5491					int,
5492
5493				) {})
5494				ret = func(env *Env) r.Value { return funv }
5495
5496				break
5497			}
5498			ret = func(env *Env) r.Value {
5499
5500				env.MarkUsedByClosure()
5501				return r.ValueOf(func(arg0 uint64,
5502
5503					arg1 int,
5504
5505				) {
5506					env := newEnv4Func(env, nbind, nintbind, debugC)
5507					env.Ints[indexes[0]] = arg0
5508
5509					*(*int)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
5510
5511					funcbody(env)
5512
5513					env.freeEnv4Func()
5514				})
5515			}
5516		}
5517	case r.Int8:
5518
5519		{
5520			if funcbody == nil {
5521				funv := r.ValueOf(func(uint64,
5522
5523					int8,
5524
5525				) {})
5526				ret = func(env *Env) r.Value { return funv }
5527
5528				break
5529			}
5530			ret = func(env *Env) r.Value {
5531
5532				env.MarkUsedByClosure()
5533				return r.ValueOf(func(arg0 uint64,
5534
5535					arg1 int8,
5536
5537				) {
5538					env := newEnv4Func(env, nbind, nintbind, debugC)
5539					env.Ints[indexes[0]] = arg0
5540
5541					*(*int8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
5542
5543					funcbody(env)
5544
5545					env.freeEnv4Func()
5546				})
5547			}
5548		}
5549	case r.Int16:
5550		{
5551			if funcbody == nil {
5552				funv := r.ValueOf(func(uint64,
5553
5554					int16,
5555
5556				) {})
5557				ret = func(env *Env) r.Value { return funv }
5558
5559				break
5560			}
5561			ret = func(env *Env) r.Value {
5562
5563				env.MarkUsedByClosure()
5564				return r.ValueOf(func(arg0 uint64,
5565
5566					arg1 int16,
5567
5568				) {
5569					env := newEnv4Func(env, nbind, nintbind, debugC)
5570					env.Ints[indexes[0]] = arg0
5571
5572					*(*int16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
5573
5574					funcbody(env)
5575
5576					env.freeEnv4Func()
5577				})
5578			}
5579		}
5580	case r.Int32:
5581		{
5582			if funcbody == nil {
5583				funv := r.ValueOf(func(uint64,
5584
5585					int32,
5586
5587				) {})
5588				ret = func(env *Env) r.Value { return funv }
5589
5590				break
5591			}
5592			ret = func(env *Env) r.Value {
5593
5594				env.MarkUsedByClosure()
5595				return r.ValueOf(func(arg0 uint64,
5596
5597					arg1 int32,
5598
5599				) {
5600					env := newEnv4Func(env, nbind, nintbind, debugC)
5601					env.Ints[indexes[0]] = arg0
5602
5603					*(*int32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
5604
5605					funcbody(env)
5606
5607					env.freeEnv4Func()
5608				})
5609			}
5610		}
5611	case r.Int64:
5612		{
5613			if funcbody == nil {
5614				funv := r.ValueOf(func(uint64,
5615
5616					int64,
5617				) {})
5618				ret = func(env *Env) r.Value { return funv }
5619
5620				break
5621			}
5622			ret = func(env *Env) r.Value {
5623
5624				env.MarkUsedByClosure()
5625				return r.ValueOf(func(arg0 uint64,
5626
5627					arg1 int64,
5628
5629				) {
5630					env := newEnv4Func(env, nbind, nintbind, debugC)
5631					env.Ints[indexes[0]] = arg0
5632
5633					*(*int64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
5634
5635					funcbody(env)
5636
5637					env.freeEnv4Func()
5638				})
5639			}
5640		}
5641	case r.Uint:
5642		{
5643			if funcbody == nil {
5644				funv := r.ValueOf(func(uint64,
5645
5646					uint) {})
5647				ret = func(env *Env) r.Value { return funv }
5648
5649				break
5650			}
5651			ret = func(env *Env) r.Value {
5652
5653				env.MarkUsedByClosure()
5654				return r.ValueOf(func(arg0 uint64,
5655
5656					arg1 uint,
5657
5658				) {
5659					env := newEnv4Func(env, nbind, nintbind, debugC)
5660					env.Ints[indexes[0]] = arg0
5661
5662					*(*uint)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
5663
5664					funcbody(env)
5665
5666					env.freeEnv4Func()
5667				})
5668			}
5669		}
5670	case r.Uint8:
5671		{
5672			if funcbody == nil {
5673				funv := r.ValueOf(func(uint64,
5674
5675					uint8) {})
5676				ret = func(env *Env) r.Value { return funv }
5677
5678				break
5679			}
5680			ret = func(env *Env) r.Value {
5681
5682				env.MarkUsedByClosure()
5683				return r.ValueOf(func(arg0 uint64,
5684
5685					arg1 uint8,
5686
5687				) {
5688					env := newEnv4Func(env, nbind, nintbind, debugC)
5689					env.Ints[indexes[0]] = arg0
5690
5691					*(*uint8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
5692
5693					funcbody(env)
5694
5695					env.freeEnv4Func()
5696				})
5697			}
5698		}
5699	case r.Uint16:
5700		{
5701			if funcbody == nil {
5702				funv := r.ValueOf(func(uint64,
5703
5704					uint16) {})
5705				ret = func(env *Env) r.Value { return funv }
5706
5707				break
5708			}
5709			ret = func(env *Env) r.Value {
5710
5711				env.MarkUsedByClosure()
5712				return r.ValueOf(func(arg0 uint64,
5713
5714					arg1 uint16,
5715
5716				) {
5717					env := newEnv4Func(env, nbind, nintbind, debugC)
5718					env.Ints[indexes[0]] = arg0
5719
5720					*(*uint16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
5721
5722					funcbody(env)
5723
5724					env.freeEnv4Func()
5725				})
5726			}
5727		}
5728	case r.Uint32:
5729		{
5730			if funcbody == nil {
5731				funv := r.ValueOf(func(uint64,
5732
5733					uint32) {})
5734				ret = func(env *Env) r.Value { return funv }
5735
5736				break
5737			}
5738			ret = func(env *Env) r.Value {
5739
5740				env.MarkUsedByClosure()
5741				return r.ValueOf(func(arg0 uint64,
5742
5743					arg1 uint32,
5744
5745				) {
5746					env := newEnv4Func(env, nbind, nintbind, debugC)
5747					env.Ints[indexes[0]] = arg0
5748
5749					*(*uint32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
5750
5751					funcbody(env)
5752
5753					env.freeEnv4Func()
5754				})
5755			}
5756		}
5757	case r.Uint64:
5758		{
5759			if funcbody == nil {
5760				funv := r.ValueOf(func(uint64,
5761
5762					uint64) {})
5763				ret = func(env *Env) r.Value { return funv }
5764
5765				break
5766			}
5767			ret = func(env *Env) r.Value {
5768
5769				env.MarkUsedByClosure()
5770				return r.ValueOf(func(arg0 uint64,
5771
5772					arg1 uint64,
5773
5774				) {
5775					env := newEnv4Func(env, nbind, nintbind, debugC)
5776					env.Ints[indexes[0]] = arg0
5777
5778					env.Ints[indexes[1]] = arg1
5779
5780					funcbody(env)
5781
5782					env.freeEnv4Func()
5783				})
5784			}
5785		}
5786	case r.Uintptr:
5787		{
5788			if funcbody == nil {
5789				funv := r.ValueOf(func(uint64,
5790
5791					uintptr) {})
5792				ret = func(env *Env) r.Value { return funv }
5793
5794				break
5795			}
5796			ret = func(env *Env) r.Value {
5797
5798				env.MarkUsedByClosure()
5799				return r.ValueOf(func(arg0 uint64,
5800
5801					arg1 uintptr,
5802
5803				) {
5804					env := newEnv4Func(env, nbind, nintbind, debugC)
5805					env.Ints[indexes[0]] = arg0
5806
5807					*(*uintptr)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
5808
5809					funcbody(env)
5810
5811					env.freeEnv4Func()
5812				})
5813			}
5814		}
5815	case r.Float32:
5816		{
5817			if funcbody == nil {
5818				funv := r.ValueOf(func(uint64,
5819
5820					float32) {})
5821				ret = func(env *Env) r.Value { return funv }
5822
5823				break
5824			}
5825			ret = func(env *Env) r.Value {
5826
5827				env.MarkUsedByClosure()
5828				return r.ValueOf(func(arg0 uint64,
5829
5830					arg1 float32,
5831
5832				) {
5833					env := newEnv4Func(env, nbind, nintbind, debugC)
5834					env.Ints[indexes[0]] = arg0
5835
5836					*(*float32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
5837
5838					funcbody(env)
5839
5840					env.freeEnv4Func()
5841				})
5842			}
5843		}
5844	case r.Float64:
5845		{
5846			if funcbody == nil {
5847				funv := r.ValueOf(func(uint64,
5848
5849					float64) {})
5850				ret = func(env *Env) r.Value { return funv }
5851
5852				break
5853			}
5854			ret = func(env *Env) r.Value {
5855
5856				env.MarkUsedByClosure()
5857				return r.ValueOf(func(arg0 uint64,
5858
5859					arg1 float64,
5860
5861				) {
5862					env := newEnv4Func(env, nbind, nintbind, debugC)
5863					env.Ints[indexes[0]] = arg0
5864
5865					*(*float64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
5866
5867					funcbody(env)
5868
5869					env.freeEnv4Func()
5870				})
5871			}
5872		}
5873	case r.Complex64:
5874		{
5875			if funcbody == nil {
5876				funv := r.ValueOf(func(uint64,
5877
5878					complex64) {})
5879				ret = func(env *Env) r.Value { return funv }
5880
5881				break
5882			}
5883			ret = func(env *Env) r.Value {
5884
5885				env.MarkUsedByClosure()
5886				return r.ValueOf(func(arg0 uint64,
5887
5888					arg1 complex64,
5889				) {
5890					env := newEnv4Func(env, nbind, nintbind, debugC)
5891					env.Ints[indexes[0]] = arg0
5892
5893					*(*complex64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
5894
5895					funcbody(env)
5896
5897					env.freeEnv4Func()
5898				})
5899			}
5900		}
5901	case r.Complex128:
5902		{
5903			if funcbody == nil {
5904				funv := r.ValueOf(func(uint64,
5905
5906					complex128) {})
5907				ret = func(env *Env) r.Value { return funv }
5908
5909				break
5910			}
5911			ret = func(env *Env) r.Value {
5912
5913				env.MarkUsedByClosure()
5914				return r.ValueOf(func(arg0 uint64,
5915
5916					arg1 complex128) {
5917					env := newEnv4Func(env, nbind, nintbind, debugC)
5918					env.Ints[indexes[0]] = arg0
5919
5920					*(*complex128)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
5921
5922					funcbody(env)
5923
5924					env.freeEnv4Func()
5925				})
5926			}
5927		}
5928	case r.String:
5929		{
5930			if funcbody == nil {
5931				funv := r.ValueOf(func(uint64,
5932
5933					string) {})
5934				ret = func(env *Env) r.Value { return funv }
5935
5936				break
5937			}
5938			ret = func(env *Env) r.Value {
5939
5940				env.MarkUsedByClosure()
5941				return r.ValueOf(func(arg0 uint64,
5942
5943					arg1 string) {
5944					env := newEnv4Func(env, nbind, nintbind, debugC)
5945					env.Ints[indexes[0]] = arg0
5946
5947					{
5948						place := r.New(TypeOfString).Elem()
5949						place.SetString(arg1,
5950						)
5951						env.Vals[indexes[1]] = place
5952					}
5953
5954					funcbody(env)
5955
5956					env.freeEnv4Func()
5957				})
5958			}
5959		}
5960	}
5961	return ret
5962}
5963func func2ret0Uintptr(m *funcMaker, indexes *[2]int, karg1 r.Kind, debugC *Comp) func(*Env) r.Value {
5964
5965	nbind := m.nbind
5966	nintbind := m.nintbind
5967	funcbody := m.funcbody
5968	var ret func(*Env) r.Value
5969	switch karg1 {
5970	case r.Bool:
5971
5972		{
5973			if funcbody == nil {
5974				funv := r.ValueOf(func(uintptr,
5975
5976					bool,
5977
5978				) {})
5979				ret = func(env *Env) r.Value { return funv }
5980
5981				break
5982			}
5983			ret = func(env *Env) r.Value {
5984
5985				env.MarkUsedByClosure()
5986				return r.ValueOf(func(arg0 uintptr,
5987
5988					arg1 bool,
5989
5990				) {
5991					env := newEnv4Func(env, nbind, nintbind, debugC)
5992
5993					*(*uintptr)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
5994
5995					*(*bool)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
5996
5997					funcbody(env)
5998
5999					env.freeEnv4Func()
6000				})
6001			}
6002		}
6003	case r.Int:
6004
6005		{
6006			if funcbody == nil {
6007				funv := r.ValueOf(func(uintptr,
6008
6009					int,
6010
6011				) {})
6012				ret = func(env *Env) r.Value { return funv }
6013
6014				break
6015			}
6016			ret = func(env *Env) r.Value {
6017
6018				env.MarkUsedByClosure()
6019				return r.ValueOf(func(arg0 uintptr,
6020
6021					arg1 int,
6022
6023				) {
6024					env := newEnv4Func(env, nbind, nintbind, debugC)
6025
6026					*(*uintptr)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
6027
6028					*(*int)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
6029
6030					funcbody(env)
6031
6032					env.freeEnv4Func()
6033				})
6034			}
6035		}
6036	case r.Int8:
6037
6038		{
6039			if funcbody == nil {
6040				funv := r.ValueOf(func(uintptr,
6041
6042					int8,
6043
6044				) {})
6045				ret = func(env *Env) r.Value { return funv }
6046
6047				break
6048			}
6049			ret = func(env *Env) r.Value {
6050
6051				env.MarkUsedByClosure()
6052				return r.ValueOf(func(arg0 uintptr,
6053
6054					arg1 int8,
6055
6056				) {
6057					env := newEnv4Func(env, nbind, nintbind, debugC)
6058
6059					*(*uintptr)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
6060
6061					*(*int8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
6062
6063					funcbody(env)
6064
6065					env.freeEnv4Func()
6066				})
6067			}
6068		}
6069	case r.Int16:
6070		{
6071			if funcbody == nil {
6072				funv := r.ValueOf(func(uintptr,
6073
6074					int16,
6075
6076				) {})
6077				ret = func(env *Env) r.Value { return funv }
6078
6079				break
6080			}
6081			ret = func(env *Env) r.Value {
6082
6083				env.MarkUsedByClosure()
6084				return r.ValueOf(func(arg0 uintptr,
6085
6086					arg1 int16,
6087
6088				) {
6089					env := newEnv4Func(env, nbind, nintbind, debugC)
6090
6091					*(*uintptr)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
6092
6093					*(*int16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
6094
6095					funcbody(env)
6096
6097					env.freeEnv4Func()
6098				})
6099			}
6100		}
6101	case r.Int32:
6102		{
6103			if funcbody == nil {
6104				funv := r.ValueOf(func(uintptr,
6105
6106					int32,
6107
6108				) {})
6109				ret = func(env *Env) r.Value { return funv }
6110
6111				break
6112			}
6113			ret = func(env *Env) r.Value {
6114
6115				env.MarkUsedByClosure()
6116				return r.ValueOf(func(arg0 uintptr,
6117
6118					arg1 int32,
6119
6120				) {
6121					env := newEnv4Func(env, nbind, nintbind, debugC)
6122
6123					*(*uintptr)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
6124
6125					*(*int32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
6126
6127					funcbody(env)
6128
6129					env.freeEnv4Func()
6130				})
6131			}
6132		}
6133	case r.Int64:
6134		{
6135			if funcbody == nil {
6136				funv := r.ValueOf(func(uintptr,
6137
6138					int64,
6139				) {})
6140				ret = func(env *Env) r.Value { return funv }
6141
6142				break
6143			}
6144			ret = func(env *Env) r.Value {
6145
6146				env.MarkUsedByClosure()
6147				return r.ValueOf(func(arg0 uintptr,
6148
6149					arg1 int64,
6150
6151				) {
6152					env := newEnv4Func(env, nbind, nintbind, debugC)
6153
6154					*(*uintptr)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
6155
6156					*(*int64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
6157
6158					funcbody(env)
6159
6160					env.freeEnv4Func()
6161				})
6162			}
6163		}
6164	case r.Uint:
6165		{
6166			if funcbody == nil {
6167				funv := r.ValueOf(func(uintptr,
6168
6169					uint) {})
6170				ret = func(env *Env) r.Value { return funv }
6171
6172				break
6173			}
6174			ret = func(env *Env) r.Value {
6175
6176				env.MarkUsedByClosure()
6177				return r.ValueOf(func(arg0 uintptr,
6178
6179					arg1 uint,
6180
6181				) {
6182					env := newEnv4Func(env, nbind, nintbind, debugC)
6183
6184					*(*uintptr)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
6185
6186					*(*uint)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
6187
6188					funcbody(env)
6189
6190					env.freeEnv4Func()
6191				})
6192			}
6193		}
6194	case r.Uint8:
6195		{
6196			if funcbody == nil {
6197				funv := r.ValueOf(func(uintptr,
6198
6199					uint8) {})
6200				ret = func(env *Env) r.Value { return funv }
6201
6202				break
6203			}
6204			ret = func(env *Env) r.Value {
6205
6206				env.MarkUsedByClosure()
6207				return r.ValueOf(func(arg0 uintptr,
6208
6209					arg1 uint8,
6210
6211				) {
6212					env := newEnv4Func(env, nbind, nintbind, debugC)
6213
6214					*(*uintptr)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
6215
6216					*(*uint8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
6217
6218					funcbody(env)
6219
6220					env.freeEnv4Func()
6221				})
6222			}
6223		}
6224	case r.Uint16:
6225		{
6226			if funcbody == nil {
6227				funv := r.ValueOf(func(uintptr,
6228
6229					uint16) {})
6230				ret = func(env *Env) r.Value { return funv }
6231
6232				break
6233			}
6234			ret = func(env *Env) r.Value {
6235
6236				env.MarkUsedByClosure()
6237				return r.ValueOf(func(arg0 uintptr,
6238
6239					arg1 uint16,
6240
6241				) {
6242					env := newEnv4Func(env, nbind, nintbind, debugC)
6243
6244					*(*uintptr)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
6245
6246					*(*uint16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
6247
6248					funcbody(env)
6249
6250					env.freeEnv4Func()
6251				})
6252			}
6253		}
6254	case r.Uint32:
6255		{
6256			if funcbody == nil {
6257				funv := r.ValueOf(func(uintptr,
6258
6259					uint32) {})
6260				ret = func(env *Env) r.Value { return funv }
6261
6262				break
6263			}
6264			ret = func(env *Env) r.Value {
6265
6266				env.MarkUsedByClosure()
6267				return r.ValueOf(func(arg0 uintptr,
6268
6269					arg1 uint32,
6270
6271				) {
6272					env := newEnv4Func(env, nbind, nintbind, debugC)
6273
6274					*(*uintptr)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
6275
6276					*(*uint32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
6277
6278					funcbody(env)
6279
6280					env.freeEnv4Func()
6281				})
6282			}
6283		}
6284	case r.Uint64:
6285		{
6286			if funcbody == nil {
6287				funv := r.ValueOf(func(uintptr,
6288
6289					uint64) {})
6290				ret = func(env *Env) r.Value { return funv }
6291
6292				break
6293			}
6294			ret = func(env *Env) r.Value {
6295
6296				env.MarkUsedByClosure()
6297				return r.ValueOf(func(arg0 uintptr,
6298
6299					arg1 uint64,
6300
6301				) {
6302					env := newEnv4Func(env, nbind, nintbind, debugC)
6303
6304					*(*uintptr)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
6305
6306					env.Ints[indexes[1]] = arg1
6307
6308					funcbody(env)
6309
6310					env.freeEnv4Func()
6311				})
6312			}
6313		}
6314	case r.Uintptr:
6315		{
6316			if funcbody == nil {
6317				funv := r.ValueOf(func(uintptr,
6318
6319					uintptr) {})
6320				ret = func(env *Env) r.Value { return funv }
6321
6322				break
6323			}
6324			ret = func(env *Env) r.Value {
6325
6326				env.MarkUsedByClosure()
6327				return r.ValueOf(func(arg0 uintptr,
6328
6329					arg1 uintptr,
6330
6331				) {
6332					env := newEnv4Func(env, nbind, nintbind, debugC)
6333
6334					*(*uintptr)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
6335
6336					*(*uintptr)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
6337
6338					funcbody(env)
6339
6340					env.freeEnv4Func()
6341				})
6342			}
6343		}
6344	case r.Float32:
6345		{
6346			if funcbody == nil {
6347				funv := r.ValueOf(func(uintptr,
6348
6349					float32) {})
6350				ret = func(env *Env) r.Value { return funv }
6351
6352				break
6353			}
6354			ret = func(env *Env) r.Value {
6355
6356				env.MarkUsedByClosure()
6357				return r.ValueOf(func(arg0 uintptr,
6358
6359					arg1 float32,
6360
6361				) {
6362					env := newEnv4Func(env, nbind, nintbind, debugC)
6363
6364					*(*uintptr)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
6365
6366					*(*float32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
6367
6368					funcbody(env)
6369
6370					env.freeEnv4Func()
6371				})
6372			}
6373		}
6374	case r.Float64:
6375		{
6376			if funcbody == nil {
6377				funv := r.ValueOf(func(uintptr,
6378
6379					float64) {})
6380				ret = func(env *Env) r.Value { return funv }
6381
6382				break
6383			}
6384			ret = func(env *Env) r.Value {
6385
6386				env.MarkUsedByClosure()
6387				return r.ValueOf(func(arg0 uintptr,
6388
6389					arg1 float64,
6390
6391				) {
6392					env := newEnv4Func(env, nbind, nintbind, debugC)
6393
6394					*(*uintptr)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
6395
6396					*(*float64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
6397
6398					funcbody(env)
6399
6400					env.freeEnv4Func()
6401				})
6402			}
6403		}
6404	case r.Complex64:
6405		{
6406			if funcbody == nil {
6407				funv := r.ValueOf(func(uintptr,
6408
6409					complex64) {})
6410				ret = func(env *Env) r.Value { return funv }
6411
6412				break
6413			}
6414			ret = func(env *Env) r.Value {
6415
6416				env.MarkUsedByClosure()
6417				return r.ValueOf(func(arg0 uintptr,
6418
6419					arg1 complex64,
6420				) {
6421					env := newEnv4Func(env, nbind, nintbind, debugC)
6422
6423					*(*uintptr)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
6424
6425					*(*complex64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
6426
6427					funcbody(env)
6428
6429					env.freeEnv4Func()
6430				})
6431			}
6432		}
6433	case r.Complex128:
6434		{
6435			if funcbody == nil {
6436				funv := r.ValueOf(func(uintptr,
6437
6438					complex128) {})
6439				ret = func(env *Env) r.Value { return funv }
6440
6441				break
6442			}
6443			ret = func(env *Env) r.Value {
6444
6445				env.MarkUsedByClosure()
6446				return r.ValueOf(func(arg0 uintptr,
6447
6448					arg1 complex128) {
6449					env := newEnv4Func(env, nbind, nintbind, debugC)
6450
6451					*(*uintptr)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
6452
6453					*(*complex128)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
6454
6455					funcbody(env)
6456
6457					env.freeEnv4Func()
6458				})
6459			}
6460		}
6461	case r.String:
6462		{
6463			if funcbody == nil {
6464				funv := r.ValueOf(func(uintptr,
6465
6466					string) {})
6467				ret = func(env *Env) r.Value { return funv }
6468
6469				break
6470			}
6471			ret = func(env *Env) r.Value {
6472
6473				env.MarkUsedByClosure()
6474				return r.ValueOf(func(arg0 uintptr,
6475
6476					arg1 string) {
6477					env := newEnv4Func(env, nbind, nintbind, debugC)
6478
6479					*(*uintptr)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
6480
6481					{
6482						place := r.New(TypeOfString).Elem()
6483						place.SetString(arg1,
6484						)
6485						env.Vals[indexes[1]] = place
6486					}
6487
6488					funcbody(env)
6489
6490					env.freeEnv4Func()
6491				})
6492			}
6493		}
6494	}
6495	return ret
6496}
6497func func2ret0Float32(m *funcMaker, indexes *[2]int, karg1 r.Kind, debugC *Comp) func(*Env) r.Value {
6498
6499	nbind := m.nbind
6500	nintbind := m.nintbind
6501	funcbody := m.funcbody
6502	var ret func(*Env) r.Value
6503	switch karg1 {
6504	case r.Bool:
6505
6506		{
6507			if funcbody == nil {
6508				funv := r.ValueOf(func(float32,
6509
6510					bool,
6511
6512				) {})
6513				ret = func(env *Env) r.Value { return funv }
6514
6515				break
6516			}
6517			ret = func(env *Env) r.Value {
6518
6519				env.MarkUsedByClosure()
6520				return r.ValueOf(func(arg0 float32,
6521
6522					arg1 bool,
6523
6524				) {
6525					env := newEnv4Func(env, nbind, nintbind, debugC)
6526
6527					*(*float32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
6528
6529					*(*bool)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
6530
6531					funcbody(env)
6532
6533					env.freeEnv4Func()
6534				})
6535			}
6536		}
6537	case r.Int:
6538
6539		{
6540			if funcbody == nil {
6541				funv := r.ValueOf(func(float32,
6542
6543					int,
6544
6545				) {})
6546				ret = func(env *Env) r.Value { return funv }
6547
6548				break
6549			}
6550			ret = func(env *Env) r.Value {
6551
6552				env.MarkUsedByClosure()
6553				return r.ValueOf(func(arg0 float32,
6554
6555					arg1 int,
6556
6557				) {
6558					env := newEnv4Func(env, nbind, nintbind, debugC)
6559
6560					*(*float32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
6561
6562					*(*int)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
6563
6564					funcbody(env)
6565
6566					env.freeEnv4Func()
6567				})
6568			}
6569		}
6570	case r.Int8:
6571
6572		{
6573			if funcbody == nil {
6574				funv := r.ValueOf(func(float32,
6575
6576					int8,
6577
6578				) {})
6579				ret = func(env *Env) r.Value { return funv }
6580
6581				break
6582			}
6583			ret = func(env *Env) r.Value {
6584
6585				env.MarkUsedByClosure()
6586				return r.ValueOf(func(arg0 float32,
6587
6588					arg1 int8,
6589
6590				) {
6591					env := newEnv4Func(env, nbind, nintbind, debugC)
6592
6593					*(*float32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
6594
6595					*(*int8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
6596
6597					funcbody(env)
6598
6599					env.freeEnv4Func()
6600				})
6601			}
6602		}
6603	case r.Int16:
6604		{
6605			if funcbody == nil {
6606				funv := r.ValueOf(func(float32,
6607
6608					int16,
6609
6610				) {})
6611				ret = func(env *Env) r.Value { return funv }
6612
6613				break
6614			}
6615			ret = func(env *Env) r.Value {
6616
6617				env.MarkUsedByClosure()
6618				return r.ValueOf(func(arg0 float32,
6619
6620					arg1 int16,
6621
6622				) {
6623					env := newEnv4Func(env, nbind, nintbind, debugC)
6624
6625					*(*float32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
6626
6627					*(*int16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
6628
6629					funcbody(env)
6630
6631					env.freeEnv4Func()
6632				})
6633			}
6634		}
6635	case r.Int32:
6636		{
6637			if funcbody == nil {
6638				funv := r.ValueOf(func(float32,
6639
6640					int32,
6641
6642				) {})
6643				ret = func(env *Env) r.Value { return funv }
6644
6645				break
6646			}
6647			ret = func(env *Env) r.Value {
6648
6649				env.MarkUsedByClosure()
6650				return r.ValueOf(func(arg0 float32,
6651
6652					arg1 int32,
6653
6654				) {
6655					env := newEnv4Func(env, nbind, nintbind, debugC)
6656
6657					*(*float32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
6658
6659					*(*int32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
6660
6661					funcbody(env)
6662
6663					env.freeEnv4Func()
6664				})
6665			}
6666		}
6667	case r.Int64:
6668		{
6669			if funcbody == nil {
6670				funv := r.ValueOf(func(float32,
6671
6672					int64,
6673				) {})
6674				ret = func(env *Env) r.Value { return funv }
6675
6676				break
6677			}
6678			ret = func(env *Env) r.Value {
6679
6680				env.MarkUsedByClosure()
6681				return r.ValueOf(func(arg0 float32,
6682
6683					arg1 int64,
6684
6685				) {
6686					env := newEnv4Func(env, nbind, nintbind, debugC)
6687
6688					*(*float32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
6689
6690					*(*int64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
6691
6692					funcbody(env)
6693
6694					env.freeEnv4Func()
6695				})
6696			}
6697		}
6698	case r.Uint:
6699		{
6700			if funcbody == nil {
6701				funv := r.ValueOf(func(float32,
6702
6703					uint) {})
6704				ret = func(env *Env) r.Value { return funv }
6705
6706				break
6707			}
6708			ret = func(env *Env) r.Value {
6709
6710				env.MarkUsedByClosure()
6711				return r.ValueOf(func(arg0 float32,
6712
6713					arg1 uint,
6714
6715				) {
6716					env := newEnv4Func(env, nbind, nintbind, debugC)
6717
6718					*(*float32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
6719
6720					*(*uint)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
6721
6722					funcbody(env)
6723
6724					env.freeEnv4Func()
6725				})
6726			}
6727		}
6728	case r.Uint8:
6729		{
6730			if funcbody == nil {
6731				funv := r.ValueOf(func(float32,
6732
6733					uint8) {})
6734				ret = func(env *Env) r.Value { return funv }
6735
6736				break
6737			}
6738			ret = func(env *Env) r.Value {
6739
6740				env.MarkUsedByClosure()
6741				return r.ValueOf(func(arg0 float32,
6742
6743					arg1 uint8,
6744
6745				) {
6746					env := newEnv4Func(env, nbind, nintbind, debugC)
6747
6748					*(*float32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
6749
6750					*(*uint8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
6751
6752					funcbody(env)
6753
6754					env.freeEnv4Func()
6755				})
6756			}
6757		}
6758	case r.Uint16:
6759		{
6760			if funcbody == nil {
6761				funv := r.ValueOf(func(float32,
6762
6763					uint16) {})
6764				ret = func(env *Env) r.Value { return funv }
6765
6766				break
6767			}
6768			ret = func(env *Env) r.Value {
6769
6770				env.MarkUsedByClosure()
6771				return r.ValueOf(func(arg0 float32,
6772
6773					arg1 uint16,
6774
6775				) {
6776					env := newEnv4Func(env, nbind, nintbind, debugC)
6777
6778					*(*float32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
6779
6780					*(*uint16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
6781
6782					funcbody(env)
6783
6784					env.freeEnv4Func()
6785				})
6786			}
6787		}
6788	case r.Uint32:
6789		{
6790			if funcbody == nil {
6791				funv := r.ValueOf(func(float32,
6792
6793					uint32) {})
6794				ret = func(env *Env) r.Value { return funv }
6795
6796				break
6797			}
6798			ret = func(env *Env) r.Value {
6799
6800				env.MarkUsedByClosure()
6801				return r.ValueOf(func(arg0 float32,
6802
6803					arg1 uint32,
6804
6805				) {
6806					env := newEnv4Func(env, nbind, nintbind, debugC)
6807
6808					*(*float32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
6809
6810					*(*uint32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
6811
6812					funcbody(env)
6813
6814					env.freeEnv4Func()
6815				})
6816			}
6817		}
6818	case r.Uint64:
6819		{
6820			if funcbody == nil {
6821				funv := r.ValueOf(func(float32,
6822
6823					uint64) {})
6824				ret = func(env *Env) r.Value { return funv }
6825
6826				break
6827			}
6828			ret = func(env *Env) r.Value {
6829
6830				env.MarkUsedByClosure()
6831				return r.ValueOf(func(arg0 float32,
6832
6833					arg1 uint64,
6834
6835				) {
6836					env := newEnv4Func(env, nbind, nintbind, debugC)
6837
6838					*(*float32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
6839
6840					env.Ints[indexes[1]] = arg1
6841
6842					funcbody(env)
6843
6844					env.freeEnv4Func()
6845				})
6846			}
6847		}
6848	case r.Uintptr:
6849		{
6850			if funcbody == nil {
6851				funv := r.ValueOf(func(float32,
6852
6853					uintptr) {})
6854				ret = func(env *Env) r.Value { return funv }
6855
6856				break
6857			}
6858			ret = func(env *Env) r.Value {
6859
6860				env.MarkUsedByClosure()
6861				return r.ValueOf(func(arg0 float32,
6862
6863					arg1 uintptr,
6864
6865				) {
6866					env := newEnv4Func(env, nbind, nintbind, debugC)
6867
6868					*(*float32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
6869
6870					*(*uintptr)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
6871
6872					funcbody(env)
6873
6874					env.freeEnv4Func()
6875				})
6876			}
6877		}
6878	case r.Float32:
6879		{
6880			if funcbody == nil {
6881				funv := r.ValueOf(func(float32,
6882
6883					float32) {})
6884				ret = func(env *Env) r.Value { return funv }
6885
6886				break
6887			}
6888			ret = func(env *Env) r.Value {
6889
6890				env.MarkUsedByClosure()
6891				return r.ValueOf(func(arg0 float32,
6892
6893					arg1 float32,
6894
6895				) {
6896					env := newEnv4Func(env, nbind, nintbind, debugC)
6897
6898					*(*float32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
6899
6900					*(*float32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
6901
6902					funcbody(env)
6903
6904					env.freeEnv4Func()
6905				})
6906			}
6907		}
6908	case r.Float64:
6909		{
6910			if funcbody == nil {
6911				funv := r.ValueOf(func(float32,
6912
6913					float64) {})
6914				ret = func(env *Env) r.Value { return funv }
6915
6916				break
6917			}
6918			ret = func(env *Env) r.Value {
6919
6920				env.MarkUsedByClosure()
6921				return r.ValueOf(func(arg0 float32,
6922
6923					arg1 float64,
6924
6925				) {
6926					env := newEnv4Func(env, nbind, nintbind, debugC)
6927
6928					*(*float32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
6929
6930					*(*float64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
6931
6932					funcbody(env)
6933
6934					env.freeEnv4Func()
6935				})
6936			}
6937		}
6938	case r.Complex64:
6939		{
6940			if funcbody == nil {
6941				funv := r.ValueOf(func(float32,
6942
6943					complex64) {})
6944				ret = func(env *Env) r.Value { return funv }
6945
6946				break
6947			}
6948			ret = func(env *Env) r.Value {
6949
6950				env.MarkUsedByClosure()
6951				return r.ValueOf(func(arg0 float32,
6952
6953					arg1 complex64,
6954				) {
6955					env := newEnv4Func(env, nbind, nintbind, debugC)
6956
6957					*(*float32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
6958
6959					*(*complex64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
6960
6961					funcbody(env)
6962
6963					env.freeEnv4Func()
6964				})
6965			}
6966		}
6967	case r.Complex128:
6968		{
6969			if funcbody == nil {
6970				funv := r.ValueOf(func(float32,
6971
6972					complex128) {})
6973				ret = func(env *Env) r.Value { return funv }
6974
6975				break
6976			}
6977			ret = func(env *Env) r.Value {
6978
6979				env.MarkUsedByClosure()
6980				return r.ValueOf(func(arg0 float32,
6981
6982					arg1 complex128) {
6983					env := newEnv4Func(env, nbind, nintbind, debugC)
6984
6985					*(*float32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
6986
6987					*(*complex128)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
6988
6989					funcbody(env)
6990
6991					env.freeEnv4Func()
6992				})
6993			}
6994		}
6995	case r.String:
6996		{
6997			if funcbody == nil {
6998				funv := r.ValueOf(func(float32,
6999
7000					string) {})
7001				ret = func(env *Env) r.Value { return funv }
7002
7003				break
7004			}
7005			ret = func(env *Env) r.Value {
7006
7007				env.MarkUsedByClosure()
7008				return r.ValueOf(func(arg0 float32,
7009
7010					arg1 string) {
7011					env := newEnv4Func(env, nbind, nintbind, debugC)
7012
7013					*(*float32)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
7014
7015					{
7016						place := r.New(TypeOfString).Elem()
7017						place.SetString(arg1,
7018						)
7019						env.Vals[indexes[1]] = place
7020					}
7021
7022					funcbody(env)
7023
7024					env.freeEnv4Func()
7025				})
7026			}
7027		}
7028	}
7029	return ret
7030}
7031func func2ret0Float64(m *funcMaker, indexes *[2]int, karg1 r.Kind, debugC *Comp) func(*Env) r.Value {
7032
7033	nbind := m.nbind
7034	nintbind := m.nintbind
7035	funcbody := m.funcbody
7036	var ret func(*Env) r.Value
7037	switch karg1 {
7038	case r.Bool:
7039
7040		{
7041			if funcbody == nil {
7042				funv := r.ValueOf(func(float64,
7043
7044					bool,
7045
7046				) {})
7047				ret = func(env *Env) r.Value { return funv }
7048
7049				break
7050			}
7051			ret = func(env *Env) r.Value {
7052
7053				env.MarkUsedByClosure()
7054				return r.ValueOf(func(arg0 float64,
7055
7056					arg1 bool,
7057
7058				) {
7059					env := newEnv4Func(env, nbind, nintbind, debugC)
7060
7061					*(*float64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
7062
7063					*(*bool)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
7064
7065					funcbody(env)
7066
7067					env.freeEnv4Func()
7068				})
7069			}
7070		}
7071	case r.Int:
7072
7073		{
7074			if funcbody == nil {
7075				funv := r.ValueOf(func(float64,
7076
7077					int,
7078
7079				) {})
7080				ret = func(env *Env) r.Value { return funv }
7081
7082				break
7083			}
7084			ret = func(env *Env) r.Value {
7085
7086				env.MarkUsedByClosure()
7087				return r.ValueOf(func(arg0 float64,
7088
7089					arg1 int,
7090
7091				) {
7092					env := newEnv4Func(env, nbind, nintbind, debugC)
7093
7094					*(*float64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
7095
7096					*(*int)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
7097
7098					funcbody(env)
7099
7100					env.freeEnv4Func()
7101				})
7102			}
7103		}
7104	case r.Int8:
7105
7106		{
7107			if funcbody == nil {
7108				funv := r.ValueOf(func(float64,
7109
7110					int8,
7111
7112				) {})
7113				ret = func(env *Env) r.Value { return funv }
7114
7115				break
7116			}
7117			ret = func(env *Env) r.Value {
7118
7119				env.MarkUsedByClosure()
7120				return r.ValueOf(func(arg0 float64,
7121
7122					arg1 int8,
7123
7124				) {
7125					env := newEnv4Func(env, nbind, nintbind, debugC)
7126
7127					*(*float64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
7128
7129					*(*int8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
7130
7131					funcbody(env)
7132
7133					env.freeEnv4Func()
7134				})
7135			}
7136		}
7137	case r.Int16:
7138		{
7139			if funcbody == nil {
7140				funv := r.ValueOf(func(float64,
7141
7142					int16,
7143
7144				) {})
7145				ret = func(env *Env) r.Value { return funv }
7146
7147				break
7148			}
7149			ret = func(env *Env) r.Value {
7150
7151				env.MarkUsedByClosure()
7152				return r.ValueOf(func(arg0 float64,
7153
7154					arg1 int16,
7155
7156				) {
7157					env := newEnv4Func(env, nbind, nintbind, debugC)
7158
7159					*(*float64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
7160
7161					*(*int16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
7162
7163					funcbody(env)
7164
7165					env.freeEnv4Func()
7166				})
7167			}
7168		}
7169	case r.Int32:
7170		{
7171			if funcbody == nil {
7172				funv := r.ValueOf(func(float64,
7173
7174					int32,
7175
7176				) {})
7177				ret = func(env *Env) r.Value { return funv }
7178
7179				break
7180			}
7181			ret = func(env *Env) r.Value {
7182
7183				env.MarkUsedByClosure()
7184				return r.ValueOf(func(arg0 float64,
7185
7186					arg1 int32,
7187
7188				) {
7189					env := newEnv4Func(env, nbind, nintbind, debugC)
7190
7191					*(*float64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
7192
7193					*(*int32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
7194
7195					funcbody(env)
7196
7197					env.freeEnv4Func()
7198				})
7199			}
7200		}
7201	case r.Int64:
7202		{
7203			if funcbody == nil {
7204				funv := r.ValueOf(func(float64,
7205
7206					int64,
7207				) {})
7208				ret = func(env *Env) r.Value { return funv }
7209
7210				break
7211			}
7212			ret = func(env *Env) r.Value {
7213
7214				env.MarkUsedByClosure()
7215				return r.ValueOf(func(arg0 float64,
7216
7217					arg1 int64,
7218
7219				) {
7220					env := newEnv4Func(env, nbind, nintbind, debugC)
7221
7222					*(*float64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
7223
7224					*(*int64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
7225
7226					funcbody(env)
7227
7228					env.freeEnv4Func()
7229				})
7230			}
7231		}
7232	case r.Uint:
7233		{
7234			if funcbody == nil {
7235				funv := r.ValueOf(func(float64,
7236
7237					uint) {})
7238				ret = func(env *Env) r.Value { return funv }
7239
7240				break
7241			}
7242			ret = func(env *Env) r.Value {
7243
7244				env.MarkUsedByClosure()
7245				return r.ValueOf(func(arg0 float64,
7246
7247					arg1 uint,
7248
7249				) {
7250					env := newEnv4Func(env, nbind, nintbind, debugC)
7251
7252					*(*float64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
7253
7254					*(*uint)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
7255
7256					funcbody(env)
7257
7258					env.freeEnv4Func()
7259				})
7260			}
7261		}
7262	case r.Uint8:
7263		{
7264			if funcbody == nil {
7265				funv := r.ValueOf(func(float64,
7266
7267					uint8) {})
7268				ret = func(env *Env) r.Value { return funv }
7269
7270				break
7271			}
7272			ret = func(env *Env) r.Value {
7273
7274				env.MarkUsedByClosure()
7275				return r.ValueOf(func(arg0 float64,
7276
7277					arg1 uint8,
7278
7279				) {
7280					env := newEnv4Func(env, nbind, nintbind, debugC)
7281
7282					*(*float64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
7283
7284					*(*uint8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
7285
7286					funcbody(env)
7287
7288					env.freeEnv4Func()
7289				})
7290			}
7291		}
7292	case r.Uint16:
7293		{
7294			if funcbody == nil {
7295				funv := r.ValueOf(func(float64,
7296
7297					uint16) {})
7298				ret = func(env *Env) r.Value { return funv }
7299
7300				break
7301			}
7302			ret = func(env *Env) r.Value {
7303
7304				env.MarkUsedByClosure()
7305				return r.ValueOf(func(arg0 float64,
7306
7307					arg1 uint16,
7308
7309				) {
7310					env := newEnv4Func(env, nbind, nintbind, debugC)
7311
7312					*(*float64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
7313
7314					*(*uint16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
7315
7316					funcbody(env)
7317
7318					env.freeEnv4Func()
7319				})
7320			}
7321		}
7322	case r.Uint32:
7323		{
7324			if funcbody == nil {
7325				funv := r.ValueOf(func(float64,
7326
7327					uint32) {})
7328				ret = func(env *Env) r.Value { return funv }
7329
7330				break
7331			}
7332			ret = func(env *Env) r.Value {
7333
7334				env.MarkUsedByClosure()
7335				return r.ValueOf(func(arg0 float64,
7336
7337					arg1 uint32,
7338
7339				) {
7340					env := newEnv4Func(env, nbind, nintbind, debugC)
7341
7342					*(*float64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
7343
7344					*(*uint32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
7345
7346					funcbody(env)
7347
7348					env.freeEnv4Func()
7349				})
7350			}
7351		}
7352	case r.Uint64:
7353		{
7354			if funcbody == nil {
7355				funv := r.ValueOf(func(float64,
7356
7357					uint64) {})
7358				ret = func(env *Env) r.Value { return funv }
7359
7360				break
7361			}
7362			ret = func(env *Env) r.Value {
7363
7364				env.MarkUsedByClosure()
7365				return r.ValueOf(func(arg0 float64,
7366
7367					arg1 uint64,
7368
7369				) {
7370					env := newEnv4Func(env, nbind, nintbind, debugC)
7371
7372					*(*float64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
7373
7374					env.Ints[indexes[1]] = arg1
7375
7376					funcbody(env)
7377
7378					env.freeEnv4Func()
7379				})
7380			}
7381		}
7382	case r.Uintptr:
7383		{
7384			if funcbody == nil {
7385				funv := r.ValueOf(func(float64,
7386
7387					uintptr) {})
7388				ret = func(env *Env) r.Value { return funv }
7389
7390				break
7391			}
7392			ret = func(env *Env) r.Value {
7393
7394				env.MarkUsedByClosure()
7395				return r.ValueOf(func(arg0 float64,
7396
7397					arg1 uintptr,
7398
7399				) {
7400					env := newEnv4Func(env, nbind, nintbind, debugC)
7401
7402					*(*float64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
7403
7404					*(*uintptr)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
7405
7406					funcbody(env)
7407
7408					env.freeEnv4Func()
7409				})
7410			}
7411		}
7412	case r.Float32:
7413		{
7414			if funcbody == nil {
7415				funv := r.ValueOf(func(float64,
7416
7417					float32) {})
7418				ret = func(env *Env) r.Value { return funv }
7419
7420				break
7421			}
7422			ret = func(env *Env) r.Value {
7423
7424				env.MarkUsedByClosure()
7425				return r.ValueOf(func(arg0 float64,
7426
7427					arg1 float32,
7428
7429				) {
7430					env := newEnv4Func(env, nbind, nintbind, debugC)
7431
7432					*(*float64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
7433
7434					*(*float32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
7435
7436					funcbody(env)
7437
7438					env.freeEnv4Func()
7439				})
7440			}
7441		}
7442	case r.Float64:
7443		{
7444			if funcbody == nil {
7445				funv := r.ValueOf(func(float64,
7446
7447					float64) {})
7448				ret = func(env *Env) r.Value { return funv }
7449
7450				break
7451			}
7452			ret = func(env *Env) r.Value {
7453
7454				env.MarkUsedByClosure()
7455				return r.ValueOf(func(arg0 float64,
7456
7457					arg1 float64,
7458
7459				) {
7460					env := newEnv4Func(env, nbind, nintbind, debugC)
7461
7462					*(*float64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
7463
7464					*(*float64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
7465
7466					funcbody(env)
7467
7468					env.freeEnv4Func()
7469				})
7470			}
7471		}
7472	case r.Complex64:
7473		{
7474			if funcbody == nil {
7475				funv := r.ValueOf(func(float64,
7476
7477					complex64) {})
7478				ret = func(env *Env) r.Value { return funv }
7479
7480				break
7481			}
7482			ret = func(env *Env) r.Value {
7483
7484				env.MarkUsedByClosure()
7485				return r.ValueOf(func(arg0 float64,
7486
7487					arg1 complex64,
7488				) {
7489					env := newEnv4Func(env, nbind, nintbind, debugC)
7490
7491					*(*float64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
7492
7493					*(*complex64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
7494
7495					funcbody(env)
7496
7497					env.freeEnv4Func()
7498				})
7499			}
7500		}
7501	case r.Complex128:
7502		{
7503			if funcbody == nil {
7504				funv := r.ValueOf(func(float64,
7505
7506					complex128) {})
7507				ret = func(env *Env) r.Value { return funv }
7508
7509				break
7510			}
7511			ret = func(env *Env) r.Value {
7512
7513				env.MarkUsedByClosure()
7514				return r.ValueOf(func(arg0 float64,
7515
7516					arg1 complex128) {
7517					env := newEnv4Func(env, nbind, nintbind, debugC)
7518
7519					*(*float64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
7520
7521					*(*complex128)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
7522
7523					funcbody(env)
7524
7525					env.freeEnv4Func()
7526				})
7527			}
7528		}
7529	case r.String:
7530		{
7531			if funcbody == nil {
7532				funv := r.ValueOf(func(float64,
7533
7534					string) {})
7535				ret = func(env *Env) r.Value { return funv }
7536
7537				break
7538			}
7539			ret = func(env *Env) r.Value {
7540
7541				env.MarkUsedByClosure()
7542				return r.ValueOf(func(arg0 float64,
7543
7544					arg1 string) {
7545					env := newEnv4Func(env, nbind, nintbind, debugC)
7546
7547					*(*float64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
7548
7549					{
7550						place := r.New(TypeOfString).Elem()
7551						place.SetString(arg1,
7552						)
7553						env.Vals[indexes[1]] = place
7554					}
7555
7556					funcbody(env)
7557
7558					env.freeEnv4Func()
7559				})
7560			}
7561		}
7562	}
7563	return ret
7564}
7565func func2ret0Complex64(m *funcMaker, indexes *[2]int, karg1 r.Kind, debugC *Comp) func(*Env) r.Value {
7566
7567	nbind := m.nbind
7568	nintbind := m.nintbind
7569	funcbody := m.funcbody
7570	var ret func(*Env) r.Value
7571	switch karg1 {
7572	case r.Bool:
7573
7574		{
7575			if funcbody == nil {
7576				funv := r.ValueOf(func(complex64,
7577
7578					bool,
7579
7580				) {})
7581				ret = func(env *Env) r.Value { return funv }
7582
7583				break
7584			}
7585			ret = func(env *Env) r.Value {
7586
7587				env.MarkUsedByClosure()
7588				return r.ValueOf(func(arg0 complex64,
7589
7590					arg1 bool,
7591
7592				) {
7593					env := newEnv4Func(env, nbind, nintbind, debugC)
7594
7595					*(*complex64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
7596
7597					*(*bool)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
7598
7599					funcbody(env)
7600
7601					env.freeEnv4Func()
7602				})
7603			}
7604		}
7605	case r.Int:
7606
7607		{
7608			if funcbody == nil {
7609				funv := r.ValueOf(func(complex64,
7610
7611					int,
7612
7613				) {})
7614				ret = func(env *Env) r.Value { return funv }
7615
7616				break
7617			}
7618			ret = func(env *Env) r.Value {
7619
7620				env.MarkUsedByClosure()
7621				return r.ValueOf(func(arg0 complex64,
7622
7623					arg1 int,
7624
7625				) {
7626					env := newEnv4Func(env, nbind, nintbind, debugC)
7627
7628					*(*complex64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
7629
7630					*(*int)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
7631
7632					funcbody(env)
7633
7634					env.freeEnv4Func()
7635				})
7636			}
7637		}
7638	case r.Int8:
7639
7640		{
7641			if funcbody == nil {
7642				funv := r.ValueOf(func(complex64,
7643
7644					int8,
7645
7646				) {})
7647				ret = func(env *Env) r.Value { return funv }
7648
7649				break
7650			}
7651			ret = func(env *Env) r.Value {
7652
7653				env.MarkUsedByClosure()
7654				return r.ValueOf(func(arg0 complex64,
7655
7656					arg1 int8,
7657
7658				) {
7659					env := newEnv4Func(env, nbind, nintbind, debugC)
7660
7661					*(*complex64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
7662
7663					*(*int8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
7664
7665					funcbody(env)
7666
7667					env.freeEnv4Func()
7668				})
7669			}
7670		}
7671	case r.Int16:
7672		{
7673			if funcbody == nil {
7674				funv := r.ValueOf(func(complex64,
7675
7676					int16,
7677
7678				) {})
7679				ret = func(env *Env) r.Value { return funv }
7680
7681				break
7682			}
7683			ret = func(env *Env) r.Value {
7684
7685				env.MarkUsedByClosure()
7686				return r.ValueOf(func(arg0 complex64,
7687
7688					arg1 int16,
7689
7690				) {
7691					env := newEnv4Func(env, nbind, nintbind, debugC)
7692
7693					*(*complex64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
7694
7695					*(*int16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
7696
7697					funcbody(env)
7698
7699					env.freeEnv4Func()
7700				})
7701			}
7702		}
7703	case r.Int32:
7704		{
7705			if funcbody == nil {
7706				funv := r.ValueOf(func(complex64,
7707
7708					int32,
7709
7710				) {})
7711				ret = func(env *Env) r.Value { return funv }
7712
7713				break
7714			}
7715			ret = func(env *Env) r.Value {
7716
7717				env.MarkUsedByClosure()
7718				return r.ValueOf(func(arg0 complex64,
7719
7720					arg1 int32,
7721
7722				) {
7723					env := newEnv4Func(env, nbind, nintbind, debugC)
7724
7725					*(*complex64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
7726
7727					*(*int32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
7728
7729					funcbody(env)
7730
7731					env.freeEnv4Func()
7732				})
7733			}
7734		}
7735	case r.Int64:
7736		{
7737			if funcbody == nil {
7738				funv := r.ValueOf(func(complex64,
7739
7740					int64,
7741				) {})
7742				ret = func(env *Env) r.Value { return funv }
7743
7744				break
7745			}
7746			ret = func(env *Env) r.Value {
7747
7748				env.MarkUsedByClosure()
7749				return r.ValueOf(func(arg0 complex64,
7750
7751					arg1 int64,
7752
7753				) {
7754					env := newEnv4Func(env, nbind, nintbind, debugC)
7755
7756					*(*complex64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
7757
7758					*(*int64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
7759
7760					funcbody(env)
7761
7762					env.freeEnv4Func()
7763				})
7764			}
7765		}
7766	case r.Uint:
7767		{
7768			if funcbody == nil {
7769				funv := r.ValueOf(func(complex64,
7770
7771					uint) {})
7772				ret = func(env *Env) r.Value { return funv }
7773
7774				break
7775			}
7776			ret = func(env *Env) r.Value {
7777
7778				env.MarkUsedByClosure()
7779				return r.ValueOf(func(arg0 complex64,
7780
7781					arg1 uint,
7782
7783				) {
7784					env := newEnv4Func(env, nbind, nintbind, debugC)
7785
7786					*(*complex64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
7787
7788					*(*uint)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
7789
7790					funcbody(env)
7791
7792					env.freeEnv4Func()
7793				})
7794			}
7795		}
7796	case r.Uint8:
7797		{
7798			if funcbody == nil {
7799				funv := r.ValueOf(func(complex64,
7800
7801					uint8) {})
7802				ret = func(env *Env) r.Value { return funv }
7803
7804				break
7805			}
7806			ret = func(env *Env) r.Value {
7807
7808				env.MarkUsedByClosure()
7809				return r.ValueOf(func(arg0 complex64,
7810
7811					arg1 uint8,
7812
7813				) {
7814					env := newEnv4Func(env, nbind, nintbind, debugC)
7815
7816					*(*complex64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
7817
7818					*(*uint8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
7819
7820					funcbody(env)
7821
7822					env.freeEnv4Func()
7823				})
7824			}
7825		}
7826	case r.Uint16:
7827		{
7828			if funcbody == nil {
7829				funv := r.ValueOf(func(complex64,
7830
7831					uint16) {})
7832				ret = func(env *Env) r.Value { return funv }
7833
7834				break
7835			}
7836			ret = func(env *Env) r.Value {
7837
7838				env.MarkUsedByClosure()
7839				return r.ValueOf(func(arg0 complex64,
7840
7841					arg1 uint16,
7842
7843				) {
7844					env := newEnv4Func(env, nbind, nintbind, debugC)
7845
7846					*(*complex64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
7847
7848					*(*uint16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
7849
7850					funcbody(env)
7851
7852					env.freeEnv4Func()
7853				})
7854			}
7855		}
7856	case r.Uint32:
7857		{
7858			if funcbody == nil {
7859				funv := r.ValueOf(func(complex64,
7860
7861					uint32) {})
7862				ret = func(env *Env) r.Value { return funv }
7863
7864				break
7865			}
7866			ret = func(env *Env) r.Value {
7867
7868				env.MarkUsedByClosure()
7869				return r.ValueOf(func(arg0 complex64,
7870
7871					arg1 uint32,
7872
7873				) {
7874					env := newEnv4Func(env, nbind, nintbind, debugC)
7875
7876					*(*complex64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
7877
7878					*(*uint32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
7879
7880					funcbody(env)
7881
7882					env.freeEnv4Func()
7883				})
7884			}
7885		}
7886	case r.Uint64:
7887		{
7888			if funcbody == nil {
7889				funv := r.ValueOf(func(complex64,
7890
7891					uint64) {})
7892				ret = func(env *Env) r.Value { return funv }
7893
7894				break
7895			}
7896			ret = func(env *Env) r.Value {
7897
7898				env.MarkUsedByClosure()
7899				return r.ValueOf(func(arg0 complex64,
7900
7901					arg1 uint64,
7902
7903				) {
7904					env := newEnv4Func(env, nbind, nintbind, debugC)
7905
7906					*(*complex64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
7907
7908					env.Ints[indexes[1]] = arg1
7909
7910					funcbody(env)
7911
7912					env.freeEnv4Func()
7913				})
7914			}
7915		}
7916	case r.Uintptr:
7917		{
7918			if funcbody == nil {
7919				funv := r.ValueOf(func(complex64,
7920
7921					uintptr) {})
7922				ret = func(env *Env) r.Value { return funv }
7923
7924				break
7925			}
7926			ret = func(env *Env) r.Value {
7927
7928				env.MarkUsedByClosure()
7929				return r.ValueOf(func(arg0 complex64,
7930
7931					arg1 uintptr,
7932
7933				) {
7934					env := newEnv4Func(env, nbind, nintbind, debugC)
7935
7936					*(*complex64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
7937
7938					*(*uintptr)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
7939
7940					funcbody(env)
7941
7942					env.freeEnv4Func()
7943				})
7944			}
7945		}
7946	case r.Float32:
7947		{
7948			if funcbody == nil {
7949				funv := r.ValueOf(func(complex64,
7950
7951					float32) {})
7952				ret = func(env *Env) r.Value { return funv }
7953
7954				break
7955			}
7956			ret = func(env *Env) r.Value {
7957
7958				env.MarkUsedByClosure()
7959				return r.ValueOf(func(arg0 complex64,
7960
7961					arg1 float32,
7962
7963				) {
7964					env := newEnv4Func(env, nbind, nintbind, debugC)
7965
7966					*(*complex64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
7967
7968					*(*float32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
7969
7970					funcbody(env)
7971
7972					env.freeEnv4Func()
7973				})
7974			}
7975		}
7976	case r.Float64:
7977		{
7978			if funcbody == nil {
7979				funv := r.ValueOf(func(complex64,
7980
7981					float64) {})
7982				ret = func(env *Env) r.Value { return funv }
7983
7984				break
7985			}
7986			ret = func(env *Env) r.Value {
7987
7988				env.MarkUsedByClosure()
7989				return r.ValueOf(func(arg0 complex64,
7990
7991					arg1 float64,
7992
7993				) {
7994					env := newEnv4Func(env, nbind, nintbind, debugC)
7995
7996					*(*complex64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
7997
7998					*(*float64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
7999
8000					funcbody(env)
8001
8002					env.freeEnv4Func()
8003				})
8004			}
8005		}
8006	case r.Complex64:
8007		{
8008			if funcbody == nil {
8009				funv := r.ValueOf(func(complex64,
8010
8011					complex64) {})
8012				ret = func(env *Env) r.Value { return funv }
8013
8014				break
8015			}
8016			ret = func(env *Env) r.Value {
8017
8018				env.MarkUsedByClosure()
8019				return r.ValueOf(func(arg0 complex64,
8020
8021					arg1 complex64,
8022				) {
8023					env := newEnv4Func(env, nbind, nintbind, debugC)
8024
8025					*(*complex64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
8026
8027					*(*complex64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
8028
8029					funcbody(env)
8030
8031					env.freeEnv4Func()
8032				})
8033			}
8034		}
8035	case r.Complex128:
8036		{
8037			if funcbody == nil {
8038				funv := r.ValueOf(func(complex64,
8039
8040					complex128) {})
8041				ret = func(env *Env) r.Value { return funv }
8042
8043				break
8044			}
8045			ret = func(env *Env) r.Value {
8046
8047				env.MarkUsedByClosure()
8048				return r.ValueOf(func(arg0 complex64,
8049
8050					arg1 complex128) {
8051					env := newEnv4Func(env, nbind, nintbind, debugC)
8052
8053					*(*complex64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
8054
8055					*(*complex128)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
8056
8057					funcbody(env)
8058
8059					env.freeEnv4Func()
8060				})
8061			}
8062		}
8063	case r.String:
8064		{
8065			if funcbody == nil {
8066				funv := r.ValueOf(func(complex64,
8067
8068					string) {})
8069				ret = func(env *Env) r.Value { return funv }
8070
8071				break
8072			}
8073			ret = func(env *Env) r.Value {
8074
8075				env.MarkUsedByClosure()
8076				return r.ValueOf(func(arg0 complex64,
8077
8078					arg1 string) {
8079					env := newEnv4Func(env, nbind, nintbind, debugC)
8080
8081					*(*complex64)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
8082
8083					{
8084						place := r.New(TypeOfString).Elem()
8085						place.SetString(arg1,
8086						)
8087						env.Vals[indexes[1]] = place
8088					}
8089
8090					funcbody(env)
8091
8092					env.freeEnv4Func()
8093				})
8094			}
8095		}
8096	}
8097	return ret
8098}
8099func func2ret0Complex128(m *funcMaker, indexes *[2]int, karg1 r.Kind, debugC *Comp) func(*Env) r.Value {
8100
8101	nbind := m.nbind
8102	nintbind := m.nintbind
8103	funcbody := m.funcbody
8104	var ret func(*Env) r.Value
8105	switch karg1 {
8106	case r.Bool:
8107
8108		{
8109			if funcbody == nil {
8110				funv := r.ValueOf(func(complex128,
8111
8112					bool,
8113
8114				) {})
8115				ret = func(env *Env) r.Value { return funv }
8116
8117				break
8118			}
8119			ret = func(env *Env) r.Value {
8120
8121				env.MarkUsedByClosure()
8122				return r.ValueOf(func(arg0 complex128,
8123
8124					arg1 bool,
8125
8126				) {
8127					env := newEnv4Func(env, nbind, nintbind, debugC)
8128
8129					*(*complex128)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
8130
8131					*(*bool)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
8132
8133					funcbody(env)
8134
8135					env.freeEnv4Func()
8136				})
8137			}
8138		}
8139	case r.Int:
8140
8141		{
8142			if funcbody == nil {
8143				funv := r.ValueOf(func(complex128,
8144
8145					int,
8146
8147				) {})
8148				ret = func(env *Env) r.Value { return funv }
8149
8150				break
8151			}
8152			ret = func(env *Env) r.Value {
8153
8154				env.MarkUsedByClosure()
8155				return r.ValueOf(func(arg0 complex128,
8156
8157					arg1 int,
8158
8159				) {
8160					env := newEnv4Func(env, nbind, nintbind, debugC)
8161
8162					*(*complex128)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
8163
8164					*(*int)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
8165
8166					funcbody(env)
8167
8168					env.freeEnv4Func()
8169				})
8170			}
8171		}
8172	case r.Int8:
8173
8174		{
8175			if funcbody == nil {
8176				funv := r.ValueOf(func(complex128,
8177
8178					int8,
8179
8180				) {})
8181				ret = func(env *Env) r.Value { return funv }
8182
8183				break
8184			}
8185			ret = func(env *Env) r.Value {
8186
8187				env.MarkUsedByClosure()
8188				return r.ValueOf(func(arg0 complex128,
8189
8190					arg1 int8,
8191
8192				) {
8193					env := newEnv4Func(env, nbind, nintbind, debugC)
8194
8195					*(*complex128)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
8196
8197					*(*int8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
8198
8199					funcbody(env)
8200
8201					env.freeEnv4Func()
8202				})
8203			}
8204		}
8205	case r.Int16:
8206		{
8207			if funcbody == nil {
8208				funv := r.ValueOf(func(complex128,
8209
8210					int16,
8211
8212				) {})
8213				ret = func(env *Env) r.Value { return funv }
8214
8215				break
8216			}
8217			ret = func(env *Env) r.Value {
8218
8219				env.MarkUsedByClosure()
8220				return r.ValueOf(func(arg0 complex128,
8221
8222					arg1 int16,
8223
8224				) {
8225					env := newEnv4Func(env, nbind, nintbind, debugC)
8226
8227					*(*complex128)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
8228
8229					*(*int16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
8230
8231					funcbody(env)
8232
8233					env.freeEnv4Func()
8234				})
8235			}
8236		}
8237	case r.Int32:
8238		{
8239			if funcbody == nil {
8240				funv := r.ValueOf(func(complex128,
8241
8242					int32,
8243
8244				) {})
8245				ret = func(env *Env) r.Value { return funv }
8246
8247				break
8248			}
8249			ret = func(env *Env) r.Value {
8250
8251				env.MarkUsedByClosure()
8252				return r.ValueOf(func(arg0 complex128,
8253
8254					arg1 int32,
8255
8256				) {
8257					env := newEnv4Func(env, nbind, nintbind, debugC)
8258
8259					*(*complex128)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
8260
8261					*(*int32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
8262
8263					funcbody(env)
8264
8265					env.freeEnv4Func()
8266				})
8267			}
8268		}
8269	case r.Int64:
8270		{
8271			if funcbody == nil {
8272				funv := r.ValueOf(func(complex128,
8273
8274					int64,
8275				) {})
8276				ret = func(env *Env) r.Value { return funv }
8277
8278				break
8279			}
8280			ret = func(env *Env) r.Value {
8281
8282				env.MarkUsedByClosure()
8283				return r.ValueOf(func(arg0 complex128,
8284
8285					arg1 int64,
8286
8287				) {
8288					env := newEnv4Func(env, nbind, nintbind, debugC)
8289
8290					*(*complex128)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
8291
8292					*(*int64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
8293
8294					funcbody(env)
8295
8296					env.freeEnv4Func()
8297				})
8298			}
8299		}
8300	case r.Uint:
8301		{
8302			if funcbody == nil {
8303				funv := r.ValueOf(func(complex128,
8304
8305					uint) {})
8306				ret = func(env *Env) r.Value { return funv }
8307
8308				break
8309			}
8310			ret = func(env *Env) r.Value {
8311
8312				env.MarkUsedByClosure()
8313				return r.ValueOf(func(arg0 complex128,
8314
8315					arg1 uint,
8316
8317				) {
8318					env := newEnv4Func(env, nbind, nintbind, debugC)
8319
8320					*(*complex128)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
8321
8322					*(*uint)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
8323
8324					funcbody(env)
8325
8326					env.freeEnv4Func()
8327				})
8328			}
8329		}
8330	case r.Uint8:
8331		{
8332			if funcbody == nil {
8333				funv := r.ValueOf(func(complex128,
8334
8335					uint8) {})
8336				ret = func(env *Env) r.Value { return funv }
8337
8338				break
8339			}
8340			ret = func(env *Env) r.Value {
8341
8342				env.MarkUsedByClosure()
8343				return r.ValueOf(func(arg0 complex128,
8344
8345					arg1 uint8,
8346
8347				) {
8348					env := newEnv4Func(env, nbind, nintbind, debugC)
8349
8350					*(*complex128)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
8351
8352					*(*uint8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
8353
8354					funcbody(env)
8355
8356					env.freeEnv4Func()
8357				})
8358			}
8359		}
8360	case r.Uint16:
8361		{
8362			if funcbody == nil {
8363				funv := r.ValueOf(func(complex128,
8364
8365					uint16) {})
8366				ret = func(env *Env) r.Value { return funv }
8367
8368				break
8369			}
8370			ret = func(env *Env) r.Value {
8371
8372				env.MarkUsedByClosure()
8373				return r.ValueOf(func(arg0 complex128,
8374
8375					arg1 uint16,
8376
8377				) {
8378					env := newEnv4Func(env, nbind, nintbind, debugC)
8379
8380					*(*complex128)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
8381
8382					*(*uint16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
8383
8384					funcbody(env)
8385
8386					env.freeEnv4Func()
8387				})
8388			}
8389		}
8390	case r.Uint32:
8391		{
8392			if funcbody == nil {
8393				funv := r.ValueOf(func(complex128,
8394
8395					uint32) {})
8396				ret = func(env *Env) r.Value { return funv }
8397
8398				break
8399			}
8400			ret = func(env *Env) r.Value {
8401
8402				env.MarkUsedByClosure()
8403				return r.ValueOf(func(arg0 complex128,
8404
8405					arg1 uint32,
8406
8407				) {
8408					env := newEnv4Func(env, nbind, nintbind, debugC)
8409
8410					*(*complex128)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
8411
8412					*(*uint32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
8413
8414					funcbody(env)
8415
8416					env.freeEnv4Func()
8417				})
8418			}
8419		}
8420	case r.Uint64:
8421		{
8422			if funcbody == nil {
8423				funv := r.ValueOf(func(complex128,
8424
8425					uint64) {})
8426				ret = func(env *Env) r.Value { return funv }
8427
8428				break
8429			}
8430			ret = func(env *Env) r.Value {
8431
8432				env.MarkUsedByClosure()
8433				return r.ValueOf(func(arg0 complex128,
8434
8435					arg1 uint64,
8436
8437				) {
8438					env := newEnv4Func(env, nbind, nintbind, debugC)
8439
8440					*(*complex128)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
8441
8442					env.Ints[indexes[1]] = arg1
8443
8444					funcbody(env)
8445
8446					env.freeEnv4Func()
8447				})
8448			}
8449		}
8450	case r.Uintptr:
8451		{
8452			if funcbody == nil {
8453				funv := r.ValueOf(func(complex128,
8454
8455					uintptr) {})
8456				ret = func(env *Env) r.Value { return funv }
8457
8458				break
8459			}
8460			ret = func(env *Env) r.Value {
8461
8462				env.MarkUsedByClosure()
8463				return r.ValueOf(func(arg0 complex128,
8464
8465					arg1 uintptr,
8466
8467				) {
8468					env := newEnv4Func(env, nbind, nintbind, debugC)
8469
8470					*(*complex128)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
8471
8472					*(*uintptr)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
8473
8474					funcbody(env)
8475
8476					env.freeEnv4Func()
8477				})
8478			}
8479		}
8480	case r.Float32:
8481		{
8482			if funcbody == nil {
8483				funv := r.ValueOf(func(complex128,
8484
8485					float32) {})
8486				ret = func(env *Env) r.Value { return funv }
8487
8488				break
8489			}
8490			ret = func(env *Env) r.Value {
8491
8492				env.MarkUsedByClosure()
8493				return r.ValueOf(func(arg0 complex128,
8494
8495					arg1 float32,
8496
8497				) {
8498					env := newEnv4Func(env, nbind, nintbind, debugC)
8499
8500					*(*complex128)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
8501
8502					*(*float32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
8503
8504					funcbody(env)
8505
8506					env.freeEnv4Func()
8507				})
8508			}
8509		}
8510	case r.Float64:
8511		{
8512			if funcbody == nil {
8513				funv := r.ValueOf(func(complex128,
8514
8515					float64) {})
8516				ret = func(env *Env) r.Value { return funv }
8517
8518				break
8519			}
8520			ret = func(env *Env) r.Value {
8521
8522				env.MarkUsedByClosure()
8523				return r.ValueOf(func(arg0 complex128,
8524
8525					arg1 float64,
8526
8527				) {
8528					env := newEnv4Func(env, nbind, nintbind, debugC)
8529
8530					*(*complex128)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
8531
8532					*(*float64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
8533
8534					funcbody(env)
8535
8536					env.freeEnv4Func()
8537				})
8538			}
8539		}
8540	case r.Complex64:
8541		{
8542			if funcbody == nil {
8543				funv := r.ValueOf(func(complex128,
8544
8545					complex64) {})
8546				ret = func(env *Env) r.Value { return funv }
8547
8548				break
8549			}
8550			ret = func(env *Env) r.Value {
8551
8552				env.MarkUsedByClosure()
8553				return r.ValueOf(func(arg0 complex128,
8554
8555					arg1 complex64,
8556				) {
8557					env := newEnv4Func(env, nbind, nintbind, debugC)
8558
8559					*(*complex128)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
8560
8561					*(*complex64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
8562
8563					funcbody(env)
8564
8565					env.freeEnv4Func()
8566				})
8567			}
8568		}
8569	case r.Complex128:
8570		{
8571			if funcbody == nil {
8572				funv := r.ValueOf(func(complex128,
8573
8574					complex128) {})
8575				ret = func(env *Env) r.Value { return funv }
8576
8577				break
8578			}
8579			ret = func(env *Env) r.Value {
8580
8581				env.MarkUsedByClosure()
8582				return r.ValueOf(func(arg0 complex128,
8583
8584					arg1 complex128) {
8585					env := newEnv4Func(env, nbind, nintbind, debugC)
8586
8587					*(*complex128)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
8588
8589					*(*complex128)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
8590
8591					funcbody(env)
8592
8593					env.freeEnv4Func()
8594				})
8595			}
8596		}
8597	case r.String:
8598		{
8599			if funcbody == nil {
8600				funv := r.ValueOf(func(complex128,
8601
8602					string) {})
8603				ret = func(env *Env) r.Value { return funv }
8604
8605				break
8606			}
8607			ret = func(env *Env) r.Value {
8608
8609				env.MarkUsedByClosure()
8610				return r.ValueOf(func(arg0 complex128,
8611
8612					arg1 string) {
8613					env := newEnv4Func(env, nbind, nintbind, debugC)
8614
8615					*(*complex128)(unsafe.Pointer(&env.Ints[indexes[0]])) = arg0
8616
8617					{
8618						place := r.New(TypeOfString).Elem()
8619						place.SetString(arg1,
8620						)
8621						env.Vals[indexes[1]] = place
8622					}
8623
8624					funcbody(env)
8625
8626					env.freeEnv4Func()
8627				})
8628			}
8629		}
8630	}
8631	return ret
8632}
8633func func2ret0String(m *funcMaker, indexes *[2]int, karg1 r.Kind, debugC *Comp) func(*Env) r.Value {
8634
8635	nbind := m.nbind
8636	nintbind := m.nintbind
8637	funcbody := m.funcbody
8638	var ret func(*Env) r.Value
8639	switch karg1 {
8640	case r.Bool:
8641
8642		{
8643			if funcbody == nil {
8644				funv := r.ValueOf(func(string,
8645
8646					bool,
8647
8648				) {})
8649				ret = func(env *Env) r.Value { return funv }
8650
8651				break
8652			}
8653			ret = func(env *Env) r.Value {
8654
8655				env.MarkUsedByClosure()
8656				return r.ValueOf(func(arg0 string,
8657
8658					arg1 bool,
8659
8660				) {
8661					env := newEnv4Func(env, nbind, nintbind, debugC)
8662					{
8663						place := r.New(TypeOfString).Elem()
8664						place.SetString(arg0,
8665						)
8666						env.Vals[indexes[0]] = place
8667					}
8668
8669					*(*bool)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
8670
8671					funcbody(env)
8672
8673					env.freeEnv4Func()
8674				})
8675			}
8676		}
8677	case r.Int:
8678
8679		{
8680			if funcbody == nil {
8681				funv := r.ValueOf(func(string,
8682
8683					int,
8684
8685				) {})
8686				ret = func(env *Env) r.Value { return funv }
8687
8688				break
8689			}
8690			ret = func(env *Env) r.Value {
8691
8692				env.MarkUsedByClosure()
8693				return r.ValueOf(func(arg0 string,
8694
8695					arg1 int,
8696
8697				) {
8698					env := newEnv4Func(env, nbind, nintbind, debugC)
8699					{
8700						place := r.New(TypeOfString).Elem()
8701						place.SetString(arg0,
8702						)
8703						env.Vals[indexes[0]] = place
8704					}
8705
8706					*(*int)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
8707
8708					funcbody(env)
8709
8710					env.freeEnv4Func()
8711				})
8712			}
8713		}
8714	case r.Int8:
8715
8716		{
8717			if funcbody == nil {
8718				funv := r.ValueOf(func(string,
8719
8720					int8,
8721
8722				) {})
8723				ret = func(env *Env) r.Value { return funv }
8724
8725				break
8726			}
8727			ret = func(env *Env) r.Value {
8728
8729				env.MarkUsedByClosure()
8730				return r.ValueOf(func(arg0 string,
8731
8732					arg1 int8,
8733
8734				) {
8735					env := newEnv4Func(env, nbind, nintbind, debugC)
8736					{
8737						place := r.New(TypeOfString).Elem()
8738						place.SetString(arg0,
8739						)
8740						env.Vals[indexes[0]] = place
8741					}
8742
8743					*(*int8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
8744
8745					funcbody(env)
8746
8747					env.freeEnv4Func()
8748				})
8749			}
8750		}
8751	case r.Int16:
8752		{
8753			if funcbody == nil {
8754				funv := r.ValueOf(func(string,
8755
8756					int16,
8757
8758				) {})
8759				ret = func(env *Env) r.Value { return funv }
8760
8761				break
8762			}
8763			ret = func(env *Env) r.Value {
8764
8765				env.MarkUsedByClosure()
8766				return r.ValueOf(func(arg0 string,
8767
8768					arg1 int16,
8769
8770				) {
8771					env := newEnv4Func(env, nbind, nintbind, debugC)
8772					{
8773						place := r.New(TypeOfString).Elem()
8774						place.SetString(arg0,
8775						)
8776						env.Vals[indexes[0]] = place
8777					}
8778
8779					*(*int16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
8780
8781					funcbody(env)
8782
8783					env.freeEnv4Func()
8784				})
8785			}
8786		}
8787	case r.Int32:
8788		{
8789			if funcbody == nil {
8790				funv := r.ValueOf(func(string,
8791
8792					int32,
8793
8794				) {})
8795				ret = func(env *Env) r.Value { return funv }
8796
8797				break
8798			}
8799			ret = func(env *Env) r.Value {
8800
8801				env.MarkUsedByClosure()
8802				return r.ValueOf(func(arg0 string,
8803
8804					arg1 int32,
8805
8806				) {
8807					env := newEnv4Func(env, nbind, nintbind, debugC)
8808					{
8809						place := r.New(TypeOfString).Elem()
8810						place.SetString(arg0,
8811						)
8812						env.Vals[indexes[0]] = place
8813					}
8814
8815					*(*int32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
8816
8817					funcbody(env)
8818
8819					env.freeEnv4Func()
8820				})
8821			}
8822		}
8823	case r.Int64:
8824		{
8825			if funcbody == nil {
8826				funv := r.ValueOf(func(string,
8827
8828					int64,
8829				) {})
8830				ret = func(env *Env) r.Value { return funv }
8831
8832				break
8833			}
8834			ret = func(env *Env) r.Value {
8835
8836				env.MarkUsedByClosure()
8837				return r.ValueOf(func(arg0 string,
8838
8839					arg1 int64,
8840
8841				) {
8842					env := newEnv4Func(env, nbind, nintbind, debugC)
8843					{
8844						place := r.New(TypeOfString).Elem()
8845						place.SetString(arg0,
8846						)
8847						env.Vals[indexes[0]] = place
8848					}
8849
8850					*(*int64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
8851
8852					funcbody(env)
8853
8854					env.freeEnv4Func()
8855				})
8856			}
8857		}
8858	case r.Uint:
8859		{
8860			if funcbody == nil {
8861				funv := r.ValueOf(func(string,
8862
8863					uint) {})
8864				ret = func(env *Env) r.Value { return funv }
8865
8866				break
8867			}
8868			ret = func(env *Env) r.Value {
8869
8870				env.MarkUsedByClosure()
8871				return r.ValueOf(func(arg0 string,
8872
8873					arg1 uint,
8874
8875				) {
8876					env := newEnv4Func(env, nbind, nintbind, debugC)
8877					{
8878						place := r.New(TypeOfString).Elem()
8879						place.SetString(arg0,
8880						)
8881						env.Vals[indexes[0]] = place
8882					}
8883
8884					*(*uint)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
8885
8886					funcbody(env)
8887
8888					env.freeEnv4Func()
8889				})
8890			}
8891		}
8892	case r.Uint8:
8893		{
8894			if funcbody == nil {
8895				funv := r.ValueOf(func(string,
8896
8897					uint8) {})
8898				ret = func(env *Env) r.Value { return funv }
8899
8900				break
8901			}
8902			ret = func(env *Env) r.Value {
8903
8904				env.MarkUsedByClosure()
8905				return r.ValueOf(func(arg0 string,
8906
8907					arg1 uint8,
8908
8909				) {
8910					env := newEnv4Func(env, nbind, nintbind, debugC)
8911					{
8912						place := r.New(TypeOfString).Elem()
8913						place.SetString(arg0,
8914						)
8915						env.Vals[indexes[0]] = place
8916					}
8917
8918					*(*uint8)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
8919
8920					funcbody(env)
8921
8922					env.freeEnv4Func()
8923				})
8924			}
8925		}
8926	case r.Uint16:
8927		{
8928			if funcbody == nil {
8929				funv := r.ValueOf(func(string,
8930
8931					uint16) {})
8932				ret = func(env *Env) r.Value { return funv }
8933
8934				break
8935			}
8936			ret = func(env *Env) r.Value {
8937
8938				env.MarkUsedByClosure()
8939				return r.ValueOf(func(arg0 string,
8940
8941					arg1 uint16,
8942
8943				) {
8944					env := newEnv4Func(env, nbind, nintbind, debugC)
8945					{
8946						place := r.New(TypeOfString).Elem()
8947						place.SetString(arg0,
8948						)
8949						env.Vals[indexes[0]] = place
8950					}
8951
8952					*(*uint16)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
8953
8954					funcbody(env)
8955
8956					env.freeEnv4Func()
8957				})
8958			}
8959		}
8960	case r.Uint32:
8961		{
8962			if funcbody == nil {
8963				funv := r.ValueOf(func(string,
8964
8965					uint32) {})
8966				ret = func(env *Env) r.Value { return funv }
8967
8968				break
8969			}
8970			ret = func(env *Env) r.Value {
8971
8972				env.MarkUsedByClosure()
8973				return r.ValueOf(func(arg0 string,
8974
8975					arg1 uint32,
8976
8977				) {
8978					env := newEnv4Func(env, nbind, nintbind, debugC)
8979					{
8980						place := r.New(TypeOfString).Elem()
8981						place.SetString(arg0,
8982						)
8983						env.Vals[indexes[0]] = place
8984					}
8985
8986					*(*uint32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
8987
8988					funcbody(env)
8989
8990					env.freeEnv4Func()
8991				})
8992			}
8993		}
8994	case r.Uint64:
8995		{
8996			if funcbody == nil {
8997				funv := r.ValueOf(func(string,
8998
8999					uint64) {})
9000				ret = func(env *Env) r.Value { return funv }
9001
9002				break
9003			}
9004			ret = func(env *Env) r.Value {
9005
9006				env.MarkUsedByClosure()
9007				return r.ValueOf(func(arg0 string,
9008
9009					arg1 uint64,
9010
9011				) {
9012					env := newEnv4Func(env, nbind, nintbind, debugC)
9013					{
9014						place := r.New(TypeOfString).Elem()
9015						place.SetString(arg0,
9016						)
9017						env.Vals[indexes[0]] = place
9018					}
9019
9020					env.Ints[indexes[1]] = arg1
9021
9022					funcbody(env)
9023
9024					env.freeEnv4Func()
9025				})
9026			}
9027		}
9028	case r.Uintptr:
9029		{
9030			if funcbody == nil {
9031				funv := r.ValueOf(func(string,
9032
9033					uintptr) {})
9034				ret = func(env *Env) r.Value { return funv }
9035
9036				break
9037			}
9038			ret = func(env *Env) r.Value {
9039
9040				env.MarkUsedByClosure()
9041				return r.ValueOf(func(arg0 string,
9042
9043					arg1 uintptr,
9044
9045				) {
9046					env := newEnv4Func(env, nbind, nintbind, debugC)
9047					{
9048						place := r.New(TypeOfString).Elem()
9049						place.SetString(arg0,
9050						)
9051						env.Vals[indexes[0]] = place
9052					}
9053
9054					*(*uintptr)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
9055
9056					funcbody(env)
9057
9058					env.freeEnv4Func()
9059				})
9060			}
9061		}
9062	case r.Float32:
9063		{
9064			if funcbody == nil {
9065				funv := r.ValueOf(func(string,
9066
9067					float32) {})
9068				ret = func(env *Env) r.Value { return funv }
9069
9070				break
9071			}
9072			ret = func(env *Env) r.Value {
9073
9074				env.MarkUsedByClosure()
9075				return r.ValueOf(func(arg0 string,
9076
9077					arg1 float32,
9078
9079				) {
9080					env := newEnv4Func(env, nbind, nintbind, debugC)
9081					{
9082						place := r.New(TypeOfString).Elem()
9083						place.SetString(arg0,
9084						)
9085						env.Vals[indexes[0]] = place
9086					}
9087
9088					*(*float32)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
9089
9090					funcbody(env)
9091
9092					env.freeEnv4Func()
9093				})
9094			}
9095		}
9096	case r.Float64:
9097		{
9098			if funcbody == nil {
9099				funv := r.ValueOf(func(string,
9100
9101					float64) {})
9102				ret = func(env *Env) r.Value { return funv }
9103
9104				break
9105			}
9106			ret = func(env *Env) r.Value {
9107
9108				env.MarkUsedByClosure()
9109				return r.ValueOf(func(arg0 string,
9110
9111					arg1 float64,
9112
9113				) {
9114					env := newEnv4Func(env, nbind, nintbind, debugC)
9115					{
9116						place := r.New(TypeOfString).Elem()
9117						place.SetString(arg0,
9118						)
9119						env.Vals[indexes[0]] = place
9120					}
9121
9122					*(*float64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
9123
9124					funcbody(env)
9125
9126					env.freeEnv4Func()
9127				})
9128			}
9129		}
9130	case r.Complex64:
9131		{
9132			if funcbody == nil {
9133				funv := r.ValueOf(func(string,
9134
9135					complex64) {})
9136				ret = func(env *Env) r.Value { return funv }
9137
9138				break
9139			}
9140			ret = func(env *Env) r.Value {
9141
9142				env.MarkUsedByClosure()
9143				return r.ValueOf(func(arg0 string,
9144
9145					arg1 complex64,
9146				) {
9147					env := newEnv4Func(env, nbind, nintbind, debugC)
9148					{
9149						place := r.New(TypeOfString).Elem()
9150						place.SetString(arg0,
9151						)
9152						env.Vals[indexes[0]] = place
9153					}
9154
9155					*(*complex64)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
9156
9157					funcbody(env)
9158
9159					env.freeEnv4Func()
9160				})
9161			}
9162		}
9163	case r.Complex128:
9164		{
9165			if funcbody == nil {
9166				funv := r.ValueOf(func(string,
9167
9168					complex128) {})
9169				ret = func(env *Env) r.Value { return funv }
9170
9171				break
9172			}
9173			ret = func(env *Env) r.Value {
9174
9175				env.MarkUsedByClosure()
9176				return r.ValueOf(func(arg0 string,
9177
9178					arg1 complex128) {
9179					env := newEnv4Func(env, nbind, nintbind, debugC)
9180					{
9181						place := r.New(TypeOfString).Elem()
9182						place.SetString(arg0,
9183						)
9184						env.Vals[indexes[0]] = place
9185					}
9186
9187					*(*complex128)(unsafe.Pointer(&env.Ints[indexes[1]])) = arg1
9188
9189					funcbody(env)
9190
9191					env.freeEnv4Func()
9192				})
9193			}
9194		}
9195	case r.String:
9196		{
9197			if funcbody == nil {
9198				funv := r.ValueOf(func(string,
9199
9200					string) {})
9201				ret = func(env *Env) r.Value { return funv }
9202
9203				break
9204			}
9205			ret = func(env *Env) r.Value {
9206
9207				env.MarkUsedByClosure()
9208				return r.ValueOf(func(arg0 string,
9209
9210					arg1 string) {
9211					env := newEnv4Func(env, nbind, nintbind, debugC)
9212					{
9213						place := r.New(TypeOfString).Elem()
9214						place.SetString(arg0,
9215						)
9216						env.Vals[indexes[0]] = place
9217					}
9218					{
9219						place := r.New(TypeOfString).Elem()
9220						place.SetString(arg1,
9221						)
9222						env.Vals[indexes[1]] = place
9223					}
9224
9225					funcbody(env)
9226
9227					env.freeEnv4Func()
9228				})
9229			}
9230		}
9231	}
9232	return ret
9233}
9234