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