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