github.com/koko1123/flow-go-1@v0.29.6/engine/execution/testutil/fixtures_checker_heavy_contract.go (about) 1 package testutil 2 3 import "github.com/koko1123/flow-go-1/model/flow" 4 5 func DeployCheckerHeavyTransaction(authorizer flow.Address, chain flow.Chain) *flow.TransactionBody { 6 return CreateContractDeploymentTransaction("CheckerHeavy", CheckerHeavyTransaction, authorizer, chain) 7 } 8 9 const CheckerHeavyTransaction = ` 10 pub contract CheckerHeavy { 11 12 pub resource Resource0 { 13 pub let c: UInt64 14 pub let r: @Resource1 15 16 init(_ r: @Resource1) { 17 self.c = UInt64(1.0) 18 self.r <- r 19 } 20 pub fun duplicate(): @Resource0{ 21 return <- create Resource0(<-self.r.duplicate()) 22 } 23 24 pub fun check(): Bool { 25 let r <- create self.r.duplicate() 26 let c = r.check() 27 destroy r 28 return c 29 } 30 31 destroy(){ 32 pre { 33 self.check() 34 } 35 destroy self.r 36 } 37 } 38 pub resource Resource1 { 39 pub let c: UInt64 40 pub let r: @Resource2 41 42 init(_ r: @Resource2) { 43 self.c = UInt64(1.0) 44 self.r <- r 45 } 46 pub fun duplicate(): @Resource1{ 47 return <- create Resource1(<-self.r.duplicate()) 48 } 49 50 pub fun check(): Bool { 51 let r <- create self.r.duplicate() 52 let c = r.check() 53 destroy r 54 return c 55 } 56 57 destroy(){ 58 pre { 59 self.check() 60 } 61 destroy self.r 62 } 63 } 64 pub resource Resource2 { 65 pub let c: UInt64 66 pub let r: @Resource3 67 68 init(_ r: @Resource3) { 69 self.c = UInt64(1.0) 70 self.r <- r 71 } 72 pub fun duplicate(): @Resource2{ 73 return <- create Resource2(<-self.r.duplicate()) 74 } 75 76 pub fun check(): Bool { 77 let r <- create self.r.duplicate() 78 let c = r.check() 79 destroy r 80 return c 81 } 82 83 destroy(){ 84 pre { 85 self.check() 86 } 87 destroy self.r 88 } 89 } 90 pub resource Resource3 { 91 pub let c: UInt64 92 pub let r: @Resource4 93 94 init(_ r: @Resource4) { 95 self.c = UInt64(1.0) 96 self.r <- r 97 } 98 pub fun duplicate(): @Resource3{ 99 return <- create Resource3(<-self.r.duplicate()) 100 } 101 102 pub fun check(): Bool { 103 let r <- create self.r.duplicate() 104 let c = r.check() 105 destroy r 106 return c 107 } 108 109 destroy(){ 110 pre { 111 self.check() 112 } 113 destroy self.r 114 } 115 } 116 pub resource Resource4 { 117 pub let c: UInt64 118 pub let r: @Resource5 119 120 init(_ r: @Resource5) { 121 self.c = UInt64(1.0) 122 self.r <- r 123 } 124 pub fun duplicate(): @Resource4{ 125 return <- create Resource4(<-self.r.duplicate()) 126 } 127 128 pub fun check(): Bool { 129 let r <- create self.r.duplicate() 130 let c = r.check() 131 destroy r 132 return c 133 } 134 135 destroy(){ 136 pre { 137 self.check() 138 } 139 destroy self.r 140 } 141 } 142 pub resource Resource5 { 143 pub let c: UInt64 144 pub let r: @Resource6 145 146 init(_ r: @Resource6) { 147 self.c = UInt64(1.0) 148 self.r <- r 149 } 150 pub fun duplicate(): @Resource5{ 151 return <- create Resource5(<-self.r.duplicate()) 152 } 153 154 pub fun check(): Bool { 155 let r <- create self.r.duplicate() 156 let c = r.check() 157 destroy r 158 return c 159 } 160 161 destroy(){ 162 pre { 163 self.check() 164 } 165 destroy self.r 166 } 167 } 168 pub resource Resource6 { 169 pub let c: UInt64 170 pub let r: @Resource7 171 172 init(_ r: @Resource7) { 173 self.c = UInt64(1.0) 174 self.r <- r 175 } 176 pub fun duplicate(): @Resource6{ 177 return <- create Resource6(<-self.r.duplicate()) 178 } 179 180 pub fun check(): Bool { 181 let r <- create self.r.duplicate() 182 let c = r.check() 183 destroy r 184 return c 185 } 186 187 destroy(){ 188 pre { 189 self.check() 190 } 191 destroy self.r 192 } 193 } 194 pub resource Resource7 { 195 pub let c: UInt64 196 pub let r: @Resource8 197 198 init(_ r: @Resource8) { 199 self.c = UInt64(1.0) 200 self.r <- r 201 } 202 pub fun duplicate(): @Resource7{ 203 return <- create Resource7(<-self.r.duplicate()) 204 } 205 206 pub fun check(): Bool { 207 let r <- create self.r.duplicate() 208 let c = r.check() 209 destroy r 210 return c 211 } 212 213 destroy(){ 214 pre { 215 self.check() 216 } 217 destroy self.r 218 } 219 } 220 pub resource Resource8 { 221 pub let c: UInt64 222 pub let r: @Resource9 223 224 init(_ r: @Resource9) { 225 self.c = UInt64(1.0) 226 self.r <- r 227 } 228 pub fun duplicate(): @Resource8{ 229 return <- create Resource8(<-self.r.duplicate()) 230 } 231 232 pub fun check(): Bool { 233 let r <- create self.r.duplicate() 234 let c = r.check() 235 destroy r 236 return c 237 } 238 239 destroy(){ 240 pre { 241 self.check() 242 } 243 destroy self.r 244 } 245 } 246 pub resource Resource9 { 247 pub let c: UInt64 248 pub let r: @Resource10 249 250 init(_ r: @Resource10) { 251 self.c = UInt64(1.0) 252 self.r <- r 253 } 254 pub fun duplicate(): @Resource9{ 255 return <- create Resource9(<-self.r.duplicate()) 256 } 257 258 pub fun check(): Bool { 259 let r <- create self.r.duplicate() 260 let c = r.check() 261 destroy r 262 return c 263 } 264 265 destroy(){ 266 pre { 267 self.check() 268 } 269 destroy self.r 270 } 271 } 272 pub resource Resource10 { 273 pub let c: UInt64 274 pub let r: @Resource11 275 276 init(_ r: @Resource11) { 277 self.c = UInt64(1.0) 278 self.r <- r 279 } 280 pub fun duplicate(): @Resource10{ 281 return <- create Resource10(<-self.r.duplicate()) 282 } 283 284 pub fun check(): Bool { 285 let r <- create self.r.duplicate() 286 let c = r.check() 287 destroy r 288 return c 289 } 290 291 destroy(){ 292 pre { 293 self.check() 294 } 295 destroy self.r 296 } 297 } 298 pub resource Resource11 { 299 pub let c: UInt64 300 pub let r: @Resource12 301 302 init(_ r: @Resource12) { 303 self.c = UInt64(1.0) 304 self.r <- r 305 } 306 pub fun duplicate(): @Resource11{ 307 return <- create Resource11(<-self.r.duplicate()) 308 } 309 310 pub fun check(): Bool { 311 let r <- create self.r.duplicate() 312 let c = r.check() 313 destroy r 314 return c 315 } 316 317 destroy(){ 318 pre { 319 self.check() 320 } 321 destroy self.r 322 } 323 } 324 pub resource Resource12 { 325 pub let c: UInt64 326 pub let r: @Resource13 327 328 init(_ r: @Resource13) { 329 self.c = UInt64(1.0) 330 self.r <- r 331 } 332 pub fun duplicate(): @Resource12{ 333 return <- create Resource12(<-self.r.duplicate()) 334 } 335 336 pub fun check(): Bool { 337 let r <- create self.r.duplicate() 338 let c = r.check() 339 destroy r 340 return c 341 } 342 343 destroy(){ 344 pre { 345 self.check() 346 } 347 destroy self.r 348 } 349 } 350 pub resource Resource13 { 351 pub let c: UInt64 352 pub let r: @Resource14 353 354 init(_ r: @Resource14) { 355 self.c = UInt64(1.0) 356 self.r <- r 357 } 358 pub fun duplicate(): @Resource13{ 359 return <- create Resource13(<-self.r.duplicate()) 360 } 361 362 pub fun check(): Bool { 363 let r <- create self.r.duplicate() 364 let c = r.check() 365 destroy r 366 return c 367 } 368 369 destroy(){ 370 pre { 371 self.check() 372 } 373 destroy self.r 374 } 375 } 376 pub resource Resource14 { 377 pub let c: UInt64 378 pub let r: @Resource15 379 380 init(_ r: @Resource15) { 381 self.c = UInt64(1.0) 382 self.r <- r 383 } 384 pub fun duplicate(): @Resource14{ 385 return <- create Resource14(<-self.r.duplicate()) 386 } 387 388 pub fun check(): Bool { 389 let r <- create self.r.duplicate() 390 let c = r.check() 391 destroy r 392 return c 393 } 394 395 destroy(){ 396 pre { 397 self.check() 398 } 399 destroy self.r 400 } 401 } 402 pub resource Resource15 { 403 pub let c: UInt64 404 pub let r: @Resource16 405 406 init(_ r: @Resource16) { 407 self.c = UInt64(1.0) 408 self.r <- r 409 } 410 pub fun duplicate(): @Resource15{ 411 return <- create Resource15(<-self.r.duplicate()) 412 } 413 414 pub fun check(): Bool { 415 let r <- create self.r.duplicate() 416 let c = r.check() 417 destroy r 418 return c 419 } 420 421 destroy(){ 422 pre { 423 self.check() 424 } 425 destroy self.r 426 } 427 } 428 pub resource Resource16 { 429 pub let c: UInt64 430 pub let r: @Resource17 431 432 init(_ r: @Resource17) { 433 self.c = UInt64(1.0) 434 self.r <- r 435 } 436 pub fun duplicate(): @Resource16{ 437 return <- create Resource16(<-self.r.duplicate()) 438 } 439 440 pub fun check(): Bool { 441 let r <- create self.r.duplicate() 442 let c = r.check() 443 destroy r 444 return c 445 } 446 447 destroy(){ 448 pre { 449 self.check() 450 } 451 destroy self.r 452 } 453 } 454 pub resource Resource17 { 455 pub let c: UInt64 456 pub let r: @Resource18 457 458 init(_ r: @Resource18) { 459 self.c = UInt64(1.0) 460 self.r <- r 461 } 462 pub fun duplicate(): @Resource17{ 463 return <- create Resource17(<-self.r.duplicate()) 464 } 465 466 pub fun check(): Bool { 467 let r <- create self.r.duplicate() 468 let c = r.check() 469 destroy r 470 return c 471 } 472 473 destroy(){ 474 pre { 475 self.check() 476 } 477 destroy self.r 478 } 479 } 480 pub resource Resource18 { 481 pub let c: UInt64 482 pub let r: @Resource19 483 484 init(_ r: @Resource19) { 485 self.c = UInt64(1.0) 486 self.r <- r 487 } 488 pub fun duplicate(): @Resource18{ 489 return <- create Resource18(<-self.r.duplicate()) 490 } 491 492 pub fun check(): Bool { 493 let r <- create self.r.duplicate() 494 let c = r.check() 495 destroy r 496 return c 497 } 498 499 destroy(){ 500 pre { 501 self.check() 502 } 503 destroy self.r 504 } 505 } 506 pub resource Resource19 { 507 pub let c: UInt64 508 pub let r: @Resource20 509 510 init(_ r: @Resource20) { 511 self.c = UInt64(1.0) 512 self.r <- r 513 } 514 pub fun duplicate(): @Resource19{ 515 return <- create Resource19(<-self.r.duplicate()) 516 } 517 518 pub fun check(): Bool { 519 let r <- create self.r.duplicate() 520 let c = r.check() 521 destroy r 522 return c 523 } 524 525 destroy(){ 526 pre { 527 self.check() 528 } 529 destroy self.r 530 } 531 } 532 pub resource Resource20 { 533 pub let c: UInt64 534 pub let r: @Resource21 535 536 init(_ r: @Resource21) { 537 self.c = UInt64(1.0) 538 self.r <- r 539 } 540 pub fun duplicate(): @Resource20{ 541 return <- create Resource20(<-self.r.duplicate()) 542 } 543 544 pub fun check(): Bool { 545 let r <- create self.r.duplicate() 546 let c = r.check() 547 destroy r 548 return c 549 } 550 551 destroy(){ 552 pre { 553 self.check() 554 } 555 destroy self.r 556 } 557 } 558 pub resource Resource21 { 559 pub let c: UInt64 560 pub let r: @Resource22 561 562 init(_ r: @Resource22) { 563 self.c = UInt64(1.0) 564 self.r <- r 565 } 566 pub fun duplicate(): @Resource21{ 567 return <- create Resource21(<-self.r.duplicate()) 568 } 569 570 pub fun check(): Bool { 571 let r <- create self.r.duplicate() 572 let c = r.check() 573 destroy r 574 return c 575 } 576 577 destroy(){ 578 pre { 579 self.check() 580 } 581 destroy self.r 582 } 583 } 584 pub resource Resource22 { 585 pub let c: UInt64 586 pub let r: @Resource23 587 588 init(_ r: @Resource23) { 589 self.c = UInt64(1.0) 590 self.r <- r 591 } 592 pub fun duplicate(): @Resource22{ 593 return <- create Resource22(<-self.r.duplicate()) 594 } 595 596 pub fun check(): Bool { 597 let r <- create self.r.duplicate() 598 let c = r.check() 599 destroy r 600 return c 601 } 602 603 destroy(){ 604 pre { 605 self.check() 606 } 607 destroy self.r 608 } 609 } 610 pub resource Resource23 { 611 pub let c: UInt64 612 pub let r: @Resource24 613 614 init(_ r: @Resource24) { 615 self.c = UInt64(1.0) 616 self.r <- r 617 } 618 pub fun duplicate(): @Resource23{ 619 return <- create Resource23(<-self.r.duplicate()) 620 } 621 622 pub fun check(): Bool { 623 let r <- create self.r.duplicate() 624 let c = r.check() 625 destroy r 626 return c 627 } 628 629 destroy(){ 630 pre { 631 self.check() 632 } 633 destroy self.r 634 } 635 } 636 pub resource Resource24 { 637 pub let c: UInt64 638 pub let r: @Resource25 639 640 init(_ r: @Resource25) { 641 self.c = UInt64(1.0) 642 self.r <- r 643 } 644 pub fun duplicate(): @Resource24{ 645 return <- create Resource24(<-self.r.duplicate()) 646 } 647 648 pub fun check(): Bool { 649 let r <- create self.r.duplicate() 650 let c = r.check() 651 destroy r 652 return c 653 } 654 655 destroy(){ 656 pre { 657 self.check() 658 } 659 destroy self.r 660 } 661 } 662 pub resource Resource25 { 663 pub let c: UInt64 664 pub let r: @Resource26 665 666 init(_ r: @Resource26) { 667 self.c = UInt64(1.0) 668 self.r <- r 669 } 670 pub fun duplicate(): @Resource25{ 671 return <- create Resource25(<-self.r.duplicate()) 672 } 673 674 pub fun check(): Bool { 675 let r <- create self.r.duplicate() 676 let c = r.check() 677 destroy r 678 return c 679 } 680 681 destroy(){ 682 pre { 683 self.check() 684 } 685 destroy self.r 686 } 687 } 688 pub resource Resource26 { 689 pub let c: UInt64 690 pub let r: @Resource27 691 692 init(_ r: @Resource27) { 693 self.c = UInt64(1.0) 694 self.r <- r 695 } 696 pub fun duplicate(): @Resource26{ 697 return <- create Resource26(<-self.r.duplicate()) 698 } 699 700 pub fun check(): Bool { 701 let r <- create self.r.duplicate() 702 let c = r.check() 703 destroy r 704 return c 705 } 706 707 destroy(){ 708 pre { 709 self.check() 710 } 711 destroy self.r 712 } 713 } 714 pub resource Resource27 { 715 pub let c: UInt64 716 pub let r: @Resource28 717 718 init(_ r: @Resource28) { 719 self.c = UInt64(1.0) 720 self.r <- r 721 } 722 pub fun duplicate(): @Resource27{ 723 return <- create Resource27(<-self.r.duplicate()) 724 } 725 726 pub fun check(): Bool { 727 let r <- create self.r.duplicate() 728 let c = r.check() 729 destroy r 730 return c 731 } 732 733 destroy(){ 734 pre { 735 self.check() 736 } 737 destroy self.r 738 } 739 } 740 pub resource Resource28 { 741 pub let c: UInt64 742 pub let r: @Resource29 743 744 init(_ r: @Resource29) { 745 self.c = UInt64(1.0) 746 self.r <- r 747 } 748 pub fun duplicate(): @Resource28{ 749 return <- create Resource28(<-self.r.duplicate()) 750 } 751 752 pub fun check(): Bool { 753 let r <- create self.r.duplicate() 754 let c = r.check() 755 destroy r 756 return c 757 } 758 759 destroy(){ 760 pre { 761 self.check() 762 } 763 destroy self.r 764 } 765 } 766 pub resource Resource29 { 767 pub let c: UInt64 768 pub let r: @Resource30 769 770 init(_ r: @Resource30) { 771 self.c = UInt64(1.0) 772 self.r <- r 773 } 774 pub fun duplicate(): @Resource29{ 775 return <- create Resource29(<-self.r.duplicate()) 776 } 777 778 pub fun check(): Bool { 779 let r <- create self.r.duplicate() 780 let c = r.check() 781 destroy r 782 return c 783 } 784 785 destroy(){ 786 pre { 787 self.check() 788 } 789 destroy self.r 790 } 791 } 792 pub resource Resource30 { 793 pub let c: UInt64 794 pub let r: @Resource31 795 796 init(_ r: @Resource31) { 797 self.c = UInt64(1.0) 798 self.r <- r 799 } 800 pub fun duplicate(): @Resource30{ 801 return <- create Resource30(<-self.r.duplicate()) 802 } 803 804 pub fun check(): Bool { 805 let r <- create self.r.duplicate() 806 let c = r.check() 807 destroy r 808 return c 809 } 810 811 destroy(){ 812 pre { 813 self.check() 814 } 815 destroy self.r 816 } 817 } 818 pub resource Resource31 { 819 pub let c: UInt64 820 pub let r: @Resource32 821 822 init(_ r: @Resource32) { 823 self.c = UInt64(1.0) 824 self.r <- r 825 } 826 pub fun duplicate(): @Resource31{ 827 return <- create Resource31(<-self.r.duplicate()) 828 } 829 830 pub fun check(): Bool { 831 let r <- create self.r.duplicate() 832 let c = r.check() 833 destroy r 834 return c 835 } 836 837 destroy(){ 838 pre { 839 self.check() 840 } 841 destroy self.r 842 } 843 } 844 pub resource Resource32 { 845 pub let c: UInt64 846 pub let r: @Resource33 847 848 init(_ r: @Resource33) { 849 self.c = UInt64(1.0) 850 self.r <- r 851 } 852 pub fun duplicate(): @Resource32{ 853 return <- create Resource32(<-self.r.duplicate()) 854 } 855 856 pub fun check(): Bool { 857 let r <- create self.r.duplicate() 858 let c = r.check() 859 destroy r 860 return c 861 } 862 863 destroy(){ 864 pre { 865 self.check() 866 } 867 destroy self.r 868 } 869 } 870 pub resource Resource33 { 871 pub let c: UInt64 872 pub let r: @Resource34 873 874 init(_ r: @Resource34) { 875 self.c = UInt64(1.0) 876 self.r <- r 877 } 878 pub fun duplicate(): @Resource33{ 879 return <- create Resource33(<-self.r.duplicate()) 880 } 881 882 pub fun check(): Bool { 883 let r <- create self.r.duplicate() 884 let c = r.check() 885 destroy r 886 return c 887 } 888 889 destroy(){ 890 pre { 891 self.check() 892 } 893 destroy self.r 894 } 895 } 896 pub resource Resource34 { 897 pub let c: UInt64 898 pub let r: @Resource35 899 900 init(_ r: @Resource35) { 901 self.c = UInt64(1.0) 902 self.r <- r 903 } 904 pub fun duplicate(): @Resource34{ 905 return <- create Resource34(<-self.r.duplicate()) 906 } 907 908 pub fun check(): Bool { 909 let r <- create self.r.duplicate() 910 let c = r.check() 911 destroy r 912 return c 913 } 914 915 destroy(){ 916 pre { 917 self.check() 918 } 919 destroy self.r 920 } 921 } 922 pub resource Resource35 { 923 pub let c: UInt64 924 pub let r: @Resource36 925 926 init(_ r: @Resource36) { 927 self.c = UInt64(1.0) 928 self.r <- r 929 } 930 pub fun duplicate(): @Resource35{ 931 return <- create Resource35(<-self.r.duplicate()) 932 } 933 934 pub fun check(): Bool { 935 let r <- create self.r.duplicate() 936 let c = r.check() 937 destroy r 938 return c 939 } 940 941 destroy(){ 942 pre { 943 self.check() 944 } 945 destroy self.r 946 } 947 } 948 pub resource Resource36 { 949 pub let c: UInt64 950 pub let r: @Resource37 951 952 init(_ r: @Resource37) { 953 self.c = UInt64(1.0) 954 self.r <- r 955 } 956 pub fun duplicate(): @Resource36{ 957 return <- create Resource36(<-self.r.duplicate()) 958 } 959 960 pub fun check(): Bool { 961 let r <- create self.r.duplicate() 962 let c = r.check() 963 destroy r 964 return c 965 } 966 967 destroy(){ 968 pre { 969 self.check() 970 } 971 destroy self.r 972 } 973 } 974 pub resource Resource37 { 975 pub let c: UInt64 976 pub let r: @Resource38 977 978 init(_ r: @Resource38) { 979 self.c = UInt64(1.0) 980 self.r <- r 981 } 982 pub fun duplicate(): @Resource37{ 983 return <- create Resource37(<-self.r.duplicate()) 984 } 985 986 pub fun check(): Bool { 987 let r <- create self.r.duplicate() 988 let c = r.check() 989 destroy r 990 return c 991 } 992 993 destroy(){ 994 pre { 995 self.check() 996 } 997 destroy self.r 998 } 999 } 1000 pub resource Resource38 { 1001 pub let c: UInt64 1002 pub let r: @Resource39 1003 1004 init(_ r: @Resource39) { 1005 self.c = UInt64(1.0) 1006 self.r <- r 1007 } 1008 pub fun duplicate(): @Resource38{ 1009 return <- create Resource38(<-self.r.duplicate()) 1010 } 1011 1012 pub fun check(): Bool { 1013 let r <- create self.r.duplicate() 1014 let c = r.check() 1015 destroy r 1016 return c 1017 } 1018 1019 destroy(){ 1020 pre { 1021 self.check() 1022 } 1023 destroy self.r 1024 } 1025 } 1026 pub resource Resource39 { 1027 pub let c: UInt64 1028 pub let r: @Resource40 1029 1030 init(_ r: @Resource40) { 1031 self.c = UInt64(1.0) 1032 self.r <- r 1033 } 1034 pub fun duplicate(): @Resource39{ 1035 return <- create Resource39(<-self.r.duplicate()) 1036 } 1037 1038 pub fun check(): Bool { 1039 let r <- create self.r.duplicate() 1040 let c = r.check() 1041 destroy r 1042 return c 1043 } 1044 1045 destroy(){ 1046 pre { 1047 self.check() 1048 } 1049 destroy self.r 1050 } 1051 } 1052 pub resource Resource40 { 1053 pub let c: UInt64 1054 pub let r: @Resource41 1055 1056 init(_ r: @Resource41) { 1057 self.c = UInt64(1.0) 1058 self.r <- r 1059 } 1060 pub fun duplicate(): @Resource40{ 1061 return <- create Resource40(<-self.r.duplicate()) 1062 } 1063 1064 pub fun check(): Bool { 1065 let r <- create self.r.duplicate() 1066 let c = r.check() 1067 destroy r 1068 return c 1069 } 1070 1071 destroy(){ 1072 pre { 1073 self.check() 1074 } 1075 destroy self.r 1076 } 1077 } 1078 pub resource Resource41 { 1079 pub let c: UInt64 1080 pub let r: @Resource42 1081 1082 init(_ r: @Resource42) { 1083 self.c = UInt64(1.0) 1084 self.r <- r 1085 } 1086 pub fun duplicate(): @Resource41{ 1087 return <- create Resource41(<-self.r.duplicate()) 1088 } 1089 1090 pub fun check(): Bool { 1091 let r <- create self.r.duplicate() 1092 let c = r.check() 1093 destroy r 1094 return c 1095 } 1096 1097 destroy(){ 1098 pre { 1099 self.check() 1100 } 1101 destroy self.r 1102 } 1103 } 1104 pub resource Resource42 { 1105 pub let c: UInt64 1106 pub let r: @Resource43 1107 1108 init(_ r: @Resource43) { 1109 self.c = UInt64(1.0) 1110 self.r <- r 1111 } 1112 pub fun duplicate(): @Resource42{ 1113 return <- create Resource42(<-self.r.duplicate()) 1114 } 1115 1116 pub fun check(): Bool { 1117 let r <- create self.r.duplicate() 1118 let c = r.check() 1119 destroy r 1120 return c 1121 } 1122 1123 destroy(){ 1124 pre { 1125 self.check() 1126 } 1127 destroy self.r 1128 } 1129 } 1130 pub resource Resource43 { 1131 pub let c: UInt64 1132 pub let r: @Resource44 1133 1134 init(_ r: @Resource44) { 1135 self.c = UInt64(1.0) 1136 self.r <- r 1137 } 1138 pub fun duplicate(): @Resource43{ 1139 return <- create Resource43(<-self.r.duplicate()) 1140 } 1141 1142 pub fun check(): Bool { 1143 let r <- create self.r.duplicate() 1144 let c = r.check() 1145 destroy r 1146 return c 1147 } 1148 1149 destroy(){ 1150 pre { 1151 self.check() 1152 } 1153 destroy self.r 1154 } 1155 } 1156 pub resource Resource44 { 1157 pub let c: UInt64 1158 pub let r: @Resource45 1159 1160 init(_ r: @Resource45) { 1161 self.c = UInt64(1.0) 1162 self.r <- r 1163 } 1164 pub fun duplicate(): @Resource44{ 1165 return <- create Resource44(<-self.r.duplicate()) 1166 } 1167 1168 pub fun check(): Bool { 1169 let r <- create self.r.duplicate() 1170 let c = r.check() 1171 destroy r 1172 return c 1173 } 1174 1175 destroy(){ 1176 pre { 1177 self.check() 1178 } 1179 destroy self.r 1180 } 1181 } 1182 pub resource Resource45 { 1183 pub let c: UInt64 1184 pub let r: @Resource46 1185 1186 init(_ r: @Resource46) { 1187 self.c = UInt64(1.0) 1188 self.r <- r 1189 } 1190 pub fun duplicate(): @Resource45{ 1191 return <- create Resource45(<-self.r.duplicate()) 1192 } 1193 1194 pub fun check(): Bool { 1195 let r <- create self.r.duplicate() 1196 let c = r.check() 1197 destroy r 1198 return c 1199 } 1200 1201 destroy(){ 1202 pre { 1203 self.check() 1204 } 1205 destroy self.r 1206 } 1207 } 1208 pub resource Resource46 { 1209 pub let c: UInt64 1210 pub let r: @Resource47 1211 1212 init(_ r: @Resource47) { 1213 self.c = UInt64(1.0) 1214 self.r <- r 1215 } 1216 pub fun duplicate(): @Resource46{ 1217 return <- create Resource46(<-self.r.duplicate()) 1218 } 1219 1220 pub fun check(): Bool { 1221 let r <- create self.r.duplicate() 1222 let c = r.check() 1223 destroy r 1224 return c 1225 } 1226 1227 destroy(){ 1228 pre { 1229 self.check() 1230 } 1231 destroy self.r 1232 } 1233 } 1234 pub resource Resource47 { 1235 pub let c: UInt64 1236 pub let r: @Resource48 1237 1238 init(_ r: @Resource48) { 1239 self.c = UInt64(1.0) 1240 self.r <- r 1241 } 1242 pub fun duplicate(): @Resource47{ 1243 return <- create Resource47(<-self.r.duplicate()) 1244 } 1245 1246 pub fun check(): Bool { 1247 let r <- create self.r.duplicate() 1248 let c = r.check() 1249 destroy r 1250 return c 1251 } 1252 1253 destroy(){ 1254 pre { 1255 self.check() 1256 } 1257 destroy self.r 1258 } 1259 } 1260 pub resource Resource48 { 1261 pub let c: UInt64 1262 pub let r: @Resource49 1263 1264 init(_ r: @Resource49) { 1265 self.c = UInt64(1.0) 1266 self.r <- r 1267 } 1268 pub fun duplicate(): @Resource48{ 1269 return <- create Resource48(<-self.r.duplicate()) 1270 } 1271 1272 pub fun check(): Bool { 1273 let r <- create self.r.duplicate() 1274 let c = r.check() 1275 destroy r 1276 return c 1277 } 1278 1279 destroy(){ 1280 pre { 1281 self.check() 1282 } 1283 destroy self.r 1284 } 1285 } 1286 pub resource Resource49 { 1287 pub let c: UInt64 1288 pub let r: @Resource50 1289 1290 init(_ r: @Resource50) { 1291 self.c = UInt64(1.0) 1292 self.r <- r 1293 } 1294 pub fun duplicate(): @Resource49{ 1295 return <- create Resource49(<-self.r.duplicate()) 1296 } 1297 1298 pub fun check(): Bool { 1299 let r <- create self.r.duplicate() 1300 let c = r.check() 1301 destroy r 1302 return c 1303 } 1304 1305 destroy(){ 1306 pre { 1307 self.check() 1308 } 1309 destroy self.r 1310 } 1311 } 1312 pub resource Resource50 { 1313 pub let c: UInt64 1314 pub let r: @Resource51 1315 1316 init(_ r: @Resource51) { 1317 self.c = UInt64(1.0) 1318 self.r <- r 1319 } 1320 pub fun duplicate(): @Resource50{ 1321 return <- create Resource50(<-self.r.duplicate()) 1322 } 1323 1324 pub fun check(): Bool { 1325 let r <- create self.r.duplicate() 1326 let c = r.check() 1327 destroy r 1328 return c 1329 } 1330 1331 destroy(){ 1332 pre { 1333 self.check() 1334 } 1335 destroy self.r 1336 } 1337 } 1338 pub resource Resource51 { 1339 pub let c: UInt64 1340 pub let r: @Resource52 1341 1342 init(_ r: @Resource52) { 1343 self.c = UInt64(1.0) 1344 self.r <- r 1345 } 1346 pub fun duplicate(): @Resource51{ 1347 return <- create Resource51(<-self.r.duplicate()) 1348 } 1349 1350 pub fun check(): Bool { 1351 let r <- create self.r.duplicate() 1352 let c = r.check() 1353 destroy r 1354 return c 1355 } 1356 1357 destroy(){ 1358 pre { 1359 self.check() 1360 } 1361 destroy self.r 1362 } 1363 } 1364 pub resource Resource52 { 1365 pub let c: UInt64 1366 pub let r: @Resource53 1367 1368 init(_ r: @Resource53) { 1369 self.c = UInt64(1.0) 1370 self.r <- r 1371 } 1372 pub fun duplicate(): @Resource52{ 1373 return <- create Resource52(<-self.r.duplicate()) 1374 } 1375 1376 pub fun check(): Bool { 1377 let r <- create self.r.duplicate() 1378 let c = r.check() 1379 destroy r 1380 return c 1381 } 1382 1383 destroy(){ 1384 pre { 1385 self.check() 1386 } 1387 destroy self.r 1388 } 1389 } 1390 pub resource Resource53 { 1391 pub let c: UInt64 1392 pub let r: @Resource54 1393 1394 init(_ r: @Resource54) { 1395 self.c = UInt64(1.0) 1396 self.r <- r 1397 } 1398 pub fun duplicate(): @Resource53{ 1399 return <- create Resource53(<-self.r.duplicate()) 1400 } 1401 1402 pub fun check(): Bool { 1403 let r <- create self.r.duplicate() 1404 let c = r.check() 1405 destroy r 1406 return c 1407 } 1408 1409 destroy(){ 1410 pre { 1411 self.check() 1412 } 1413 destroy self.r 1414 } 1415 } 1416 pub resource Resource54 { 1417 pub let c: UInt64 1418 pub let r: @Resource55 1419 1420 init(_ r: @Resource55) { 1421 self.c = UInt64(1.0) 1422 self.r <- r 1423 } 1424 pub fun duplicate(): @Resource54{ 1425 return <- create Resource54(<-self.r.duplicate()) 1426 } 1427 1428 pub fun check(): Bool { 1429 let r <- create self.r.duplicate() 1430 let c = r.check() 1431 destroy r 1432 return c 1433 } 1434 1435 destroy(){ 1436 pre { 1437 self.check() 1438 } 1439 destroy self.r 1440 } 1441 } 1442 pub resource Resource55 { 1443 pub let c: UInt64 1444 pub let r: @Resource56 1445 1446 init(_ r: @Resource56) { 1447 self.c = UInt64(1.0) 1448 self.r <- r 1449 } 1450 pub fun duplicate(): @Resource55{ 1451 return <- create Resource55(<-self.r.duplicate()) 1452 } 1453 1454 pub fun check(): Bool { 1455 let r <- create self.r.duplicate() 1456 let c = r.check() 1457 destroy r 1458 return c 1459 } 1460 1461 destroy(){ 1462 pre { 1463 self.check() 1464 } 1465 destroy self.r 1466 } 1467 } 1468 pub resource Resource56 { 1469 pub let c: UInt64 1470 pub let r: @Resource57 1471 1472 init(_ r: @Resource57) { 1473 self.c = UInt64(1.0) 1474 self.r <- r 1475 } 1476 pub fun duplicate(): @Resource56{ 1477 return <- create Resource56(<-self.r.duplicate()) 1478 } 1479 1480 pub fun check(): Bool { 1481 let r <- create self.r.duplicate() 1482 let c = r.check() 1483 destroy r 1484 return c 1485 } 1486 1487 destroy(){ 1488 pre { 1489 self.check() 1490 } 1491 destroy self.r 1492 } 1493 } 1494 pub resource Resource57 { 1495 pub let c: UInt64 1496 pub let r: @Resource58 1497 1498 init(_ r: @Resource58) { 1499 self.c = UInt64(1.0) 1500 self.r <- r 1501 } 1502 pub fun duplicate(): @Resource57{ 1503 return <- create Resource57(<-self.r.duplicate()) 1504 } 1505 1506 pub fun check(): Bool { 1507 let r <- create self.r.duplicate() 1508 let c = r.check() 1509 destroy r 1510 return c 1511 } 1512 1513 destroy(){ 1514 pre { 1515 self.check() 1516 } 1517 destroy self.r 1518 } 1519 } 1520 pub resource Resource58 { 1521 pub let c: UInt64 1522 pub let r: @Resource59 1523 1524 init(_ r: @Resource59) { 1525 self.c = UInt64(1.0) 1526 self.r <- r 1527 } 1528 pub fun duplicate(): @Resource58{ 1529 return <- create Resource58(<-self.r.duplicate()) 1530 } 1531 1532 pub fun check(): Bool { 1533 let r <- create self.r.duplicate() 1534 let c = r.check() 1535 destroy r 1536 return c 1537 } 1538 1539 destroy(){ 1540 pre { 1541 self.check() 1542 } 1543 destroy self.r 1544 } 1545 } 1546 pub resource Resource59 { 1547 pub let c: UInt64 1548 pub let r: @Resource60 1549 1550 init(_ r: @Resource60) { 1551 self.c = UInt64(1.0) 1552 self.r <- r 1553 } 1554 pub fun duplicate(): @Resource59{ 1555 return <- create Resource59(<-self.r.duplicate()) 1556 } 1557 1558 pub fun check(): Bool { 1559 let r <- create self.r.duplicate() 1560 let c = r.check() 1561 destroy r 1562 return c 1563 } 1564 1565 destroy(){ 1566 pre { 1567 self.check() 1568 } 1569 destroy self.r 1570 } 1571 } 1572 pub resource Resource60 { 1573 pub let c: UInt64 1574 pub let r: @Resource61 1575 1576 init(_ r: @Resource61) { 1577 self.c = UInt64(1.0) 1578 self.r <- r 1579 } 1580 pub fun duplicate(): @Resource60{ 1581 return <- create Resource60(<-self.r.duplicate()) 1582 } 1583 1584 pub fun check(): Bool { 1585 let r <- create self.r.duplicate() 1586 let c = r.check() 1587 destroy r 1588 return c 1589 } 1590 1591 destroy(){ 1592 pre { 1593 self.check() 1594 } 1595 destroy self.r 1596 } 1597 } 1598 pub resource Resource61 { 1599 pub let c: UInt64 1600 pub let r: @Resource62 1601 1602 init(_ r: @Resource62) { 1603 self.c = UInt64(1.0) 1604 self.r <- r 1605 } 1606 pub fun duplicate(): @Resource61{ 1607 return <- create Resource61(<-self.r.duplicate()) 1608 } 1609 1610 pub fun check(): Bool { 1611 let r <- create self.r.duplicate() 1612 let c = r.check() 1613 destroy r 1614 return c 1615 } 1616 1617 destroy(){ 1618 pre { 1619 self.check() 1620 } 1621 destroy self.r 1622 } 1623 } 1624 pub resource Resource62 { 1625 pub let c: UInt64 1626 pub let r: @Resource63 1627 1628 init(_ r: @Resource63) { 1629 self.c = UInt64(1.0) 1630 self.r <- r 1631 } 1632 pub fun duplicate(): @Resource62{ 1633 return <- create Resource62(<-self.r.duplicate()) 1634 } 1635 1636 pub fun check(): Bool { 1637 let r <- create self.r.duplicate() 1638 let c = r.check() 1639 destroy r 1640 return c 1641 } 1642 1643 destroy(){ 1644 pre { 1645 self.check() 1646 } 1647 destroy self.r 1648 } 1649 } 1650 pub resource Resource63 { 1651 pub let c: UInt64 1652 pub let r: @Resource64 1653 1654 init(_ r: @Resource64) { 1655 self.c = UInt64(1.0) 1656 self.r <- r 1657 } 1658 pub fun duplicate(): @Resource63{ 1659 return <- create Resource63(<-self.r.duplicate()) 1660 } 1661 1662 pub fun check(): Bool { 1663 let r <- create self.r.duplicate() 1664 let c = r.check() 1665 destroy r 1666 return c 1667 } 1668 1669 destroy(){ 1670 pre { 1671 self.check() 1672 } 1673 destroy self.r 1674 } 1675 } 1676 pub resource Resource64 { 1677 pub let c: UInt64 1678 pub let r: @Resource65 1679 1680 init(_ r: @Resource65) { 1681 self.c = UInt64(1.0) 1682 self.r <- r 1683 } 1684 pub fun duplicate(): @Resource64{ 1685 return <- create Resource64(<-self.r.duplicate()) 1686 } 1687 1688 pub fun check(): Bool { 1689 let r <- create self.r.duplicate() 1690 let c = r.check() 1691 destroy r 1692 return c 1693 } 1694 1695 destroy(){ 1696 pre { 1697 self.check() 1698 } 1699 destroy self.r 1700 } 1701 } 1702 pub resource Resource65 { 1703 pub let c: UInt64 1704 pub let r: @Resource66 1705 1706 init(_ r: @Resource66) { 1707 self.c = UInt64(1.0) 1708 self.r <- r 1709 } 1710 pub fun duplicate(): @Resource65{ 1711 return <- create Resource65(<-self.r.duplicate()) 1712 } 1713 1714 pub fun check(): Bool { 1715 let r <- create self.r.duplicate() 1716 let c = r.check() 1717 destroy r 1718 return c 1719 } 1720 1721 destroy(){ 1722 pre { 1723 self.check() 1724 } 1725 destroy self.r 1726 } 1727 } 1728 pub resource Resource66 { 1729 pub let c: UInt64 1730 pub let r: @Resource67 1731 1732 init(_ r: @Resource67) { 1733 self.c = UInt64(1.0) 1734 self.r <- r 1735 } 1736 pub fun duplicate(): @Resource66{ 1737 return <- create Resource66(<-self.r.duplicate()) 1738 } 1739 1740 pub fun check(): Bool { 1741 let r <- create self.r.duplicate() 1742 let c = r.check() 1743 destroy r 1744 return c 1745 } 1746 1747 destroy(){ 1748 pre { 1749 self.check() 1750 } 1751 destroy self.r 1752 } 1753 } 1754 pub resource Resource67 { 1755 pub let c: UInt64 1756 pub let r: @Resource68 1757 1758 init(_ r: @Resource68) { 1759 self.c = UInt64(1.0) 1760 self.r <- r 1761 } 1762 pub fun duplicate(): @Resource67{ 1763 return <- create Resource67(<-self.r.duplicate()) 1764 } 1765 1766 pub fun check(): Bool { 1767 let r <- create self.r.duplicate() 1768 let c = r.check() 1769 destroy r 1770 return c 1771 } 1772 1773 destroy(){ 1774 pre { 1775 self.check() 1776 } 1777 destroy self.r 1778 } 1779 } 1780 pub resource Resource68 { 1781 pub let c: UInt64 1782 pub let r: @Resource69 1783 1784 init(_ r: @Resource69) { 1785 self.c = UInt64(1.0) 1786 self.r <- r 1787 } 1788 pub fun duplicate(): @Resource68{ 1789 return <- create Resource68(<-self.r.duplicate()) 1790 } 1791 1792 pub fun check(): Bool { 1793 let r <- create self.r.duplicate() 1794 let c = r.check() 1795 destroy r 1796 return c 1797 } 1798 1799 destroy(){ 1800 pre { 1801 self.check() 1802 } 1803 destroy self.r 1804 } 1805 } 1806 pub resource Resource69 { 1807 pub let c: UInt64 1808 pub let r: @Resource70 1809 1810 init(_ r: @Resource70) { 1811 self.c = UInt64(1.0) 1812 self.r <- r 1813 } 1814 pub fun duplicate(): @Resource69{ 1815 return <- create Resource69(<-self.r.duplicate()) 1816 } 1817 1818 pub fun check(): Bool { 1819 let r <- create self.r.duplicate() 1820 let c = r.check() 1821 destroy r 1822 return c 1823 } 1824 1825 destroy(){ 1826 pre { 1827 self.check() 1828 } 1829 destroy self.r 1830 } 1831 } 1832 pub resource Resource70 { 1833 pub let c: UInt64 1834 pub let r: @Resource71 1835 1836 init(_ r: @Resource71) { 1837 self.c = UInt64(1.0) 1838 self.r <- r 1839 } 1840 pub fun duplicate(): @Resource70{ 1841 return <- create Resource70(<-self.r.duplicate()) 1842 } 1843 1844 pub fun check(): Bool { 1845 let r <- create self.r.duplicate() 1846 let c = r.check() 1847 destroy r 1848 return c 1849 } 1850 1851 destroy(){ 1852 pre { 1853 self.check() 1854 } 1855 destroy self.r 1856 } 1857 } 1858 pub resource Resource71 { 1859 pub let c: UInt64 1860 pub let r: @Resource72 1861 1862 init(_ r: @Resource72) { 1863 self.c = UInt64(1.0) 1864 self.r <- r 1865 } 1866 pub fun duplicate(): @Resource71{ 1867 return <- create Resource71(<-self.r.duplicate()) 1868 } 1869 1870 pub fun check(): Bool { 1871 let r <- create self.r.duplicate() 1872 let c = r.check() 1873 destroy r 1874 return c 1875 } 1876 1877 destroy(){ 1878 pre { 1879 self.check() 1880 } 1881 destroy self.r 1882 } 1883 } 1884 pub resource Resource72 { 1885 pub let c: UInt64 1886 pub let r: @Resource73 1887 1888 init(_ r: @Resource73) { 1889 self.c = UInt64(1.0) 1890 self.r <- r 1891 } 1892 pub fun duplicate(): @Resource72{ 1893 return <- create Resource72(<-self.r.duplicate()) 1894 } 1895 1896 pub fun check(): Bool { 1897 let r <- create self.r.duplicate() 1898 let c = r.check() 1899 destroy r 1900 return c 1901 } 1902 1903 destroy(){ 1904 pre { 1905 self.check() 1906 } 1907 destroy self.r 1908 } 1909 } 1910 pub resource Resource73 { 1911 pub let c: UInt64 1912 pub let r: @Resource74 1913 1914 init(_ r: @Resource74) { 1915 self.c = UInt64(1.0) 1916 self.r <- r 1917 } 1918 pub fun duplicate(): @Resource73{ 1919 return <- create Resource73(<-self.r.duplicate()) 1920 } 1921 1922 pub fun check(): Bool { 1923 let r <- create self.r.duplicate() 1924 let c = r.check() 1925 destroy r 1926 return c 1927 } 1928 1929 destroy(){ 1930 pre { 1931 self.check() 1932 } 1933 destroy self.r 1934 } 1935 } 1936 pub resource Resource74 { 1937 pub let c: UInt64 1938 pub let r: @Resource75 1939 1940 init(_ r: @Resource75) { 1941 self.c = UInt64(1.0) 1942 self.r <- r 1943 } 1944 pub fun duplicate(): @Resource74{ 1945 return <- create Resource74(<-self.r.duplicate()) 1946 } 1947 1948 pub fun check(): Bool { 1949 let r <- create self.r.duplicate() 1950 let c = r.check() 1951 destroy r 1952 return c 1953 } 1954 1955 destroy(){ 1956 pre { 1957 self.check() 1958 } 1959 destroy self.r 1960 } 1961 } 1962 pub resource Resource75 { 1963 pub let c: UInt64 1964 pub let r: @Resource76 1965 1966 init(_ r: @Resource76) { 1967 self.c = UInt64(1.0) 1968 self.r <- r 1969 } 1970 pub fun duplicate(): @Resource75{ 1971 return <- create Resource75(<-self.r.duplicate()) 1972 } 1973 1974 pub fun check(): Bool { 1975 let r <- create self.r.duplicate() 1976 let c = r.check() 1977 destroy r 1978 return c 1979 } 1980 1981 destroy(){ 1982 pre { 1983 self.check() 1984 } 1985 destroy self.r 1986 } 1987 } 1988 pub resource Resource76 { 1989 pub let c: UInt64 1990 pub let r: @Resource77 1991 1992 init(_ r: @Resource77) { 1993 self.c = UInt64(1.0) 1994 self.r <- r 1995 } 1996 pub fun duplicate(): @Resource76{ 1997 return <- create Resource76(<-self.r.duplicate()) 1998 } 1999 2000 pub fun check(): Bool { 2001 let r <- create self.r.duplicate() 2002 let c = r.check() 2003 destroy r 2004 return c 2005 } 2006 2007 destroy(){ 2008 pre { 2009 self.check() 2010 } 2011 destroy self.r 2012 } 2013 } 2014 pub resource Resource77 { 2015 pub let c: UInt64 2016 pub let r: @Resource78 2017 2018 init(_ r: @Resource78) { 2019 self.c = UInt64(1.0) 2020 self.r <- r 2021 } 2022 pub fun duplicate(): @Resource77{ 2023 return <- create Resource77(<-self.r.duplicate()) 2024 } 2025 2026 pub fun check(): Bool { 2027 let r <- create self.r.duplicate() 2028 let c = r.check() 2029 destroy r 2030 return c 2031 } 2032 2033 destroy(){ 2034 pre { 2035 self.check() 2036 } 2037 destroy self.r 2038 } 2039 } 2040 pub resource Resource78 { 2041 pub let c: UInt64 2042 pub let r: @Resource79 2043 2044 init(_ r: @Resource79) { 2045 self.c = UInt64(1.0) 2046 self.r <- r 2047 } 2048 pub fun duplicate(): @Resource78{ 2049 return <- create Resource78(<-self.r.duplicate()) 2050 } 2051 2052 pub fun check(): Bool { 2053 let r <- create self.r.duplicate() 2054 let c = r.check() 2055 destroy r 2056 return c 2057 } 2058 2059 destroy(){ 2060 pre { 2061 self.check() 2062 } 2063 destroy self.r 2064 } 2065 } 2066 pub resource Resource79 { 2067 pub let c: UInt64 2068 pub let r: @Resource80 2069 2070 init(_ r: @Resource80) { 2071 self.c = UInt64(1.0) 2072 self.r <- r 2073 } 2074 pub fun duplicate(): @Resource79{ 2075 return <- create Resource79(<-self.r.duplicate()) 2076 } 2077 2078 pub fun check(): Bool { 2079 let r <- create self.r.duplicate() 2080 let c = r.check() 2081 destroy r 2082 return c 2083 } 2084 2085 destroy(){ 2086 pre { 2087 self.check() 2088 } 2089 destroy self.r 2090 } 2091 } 2092 pub resource Resource80 { 2093 pub let c: UInt64 2094 pub let r: @Resource81 2095 2096 init(_ r: @Resource81) { 2097 self.c = UInt64(1.0) 2098 self.r <- r 2099 } 2100 pub fun duplicate(): @Resource80{ 2101 return <- create Resource80(<-self.r.duplicate()) 2102 } 2103 2104 pub fun check(): Bool { 2105 let r <- create self.r.duplicate() 2106 let c = r.check() 2107 destroy r 2108 return c 2109 } 2110 2111 destroy(){ 2112 pre { 2113 self.check() 2114 } 2115 destroy self.r 2116 } 2117 } 2118 pub resource Resource81 { 2119 pub let c: UInt64 2120 pub let r: @Resource82 2121 2122 init(_ r: @Resource82) { 2123 self.c = UInt64(1.0) 2124 self.r <- r 2125 } 2126 pub fun duplicate(): @Resource81{ 2127 return <- create Resource81(<-self.r.duplicate()) 2128 } 2129 2130 pub fun check(): Bool { 2131 let r <- create self.r.duplicate() 2132 let c = r.check() 2133 destroy r 2134 return c 2135 } 2136 2137 destroy(){ 2138 pre { 2139 self.check() 2140 } 2141 destroy self.r 2142 } 2143 } 2144 pub resource Resource82 { 2145 pub let c: UInt64 2146 pub let r: @Resource83 2147 2148 init(_ r: @Resource83) { 2149 self.c = UInt64(1.0) 2150 self.r <- r 2151 } 2152 pub fun duplicate(): @Resource82{ 2153 return <- create Resource82(<-self.r.duplicate()) 2154 } 2155 2156 pub fun check(): Bool { 2157 let r <- create self.r.duplicate() 2158 let c = r.check() 2159 destroy r 2160 return c 2161 } 2162 2163 destroy(){ 2164 pre { 2165 self.check() 2166 } 2167 destroy self.r 2168 } 2169 } 2170 pub resource Resource83 { 2171 pub let c: UInt64 2172 pub let r: @Resource84 2173 2174 init(_ r: @Resource84) { 2175 self.c = UInt64(1.0) 2176 self.r <- r 2177 } 2178 pub fun duplicate(): @Resource83{ 2179 return <- create Resource83(<-self.r.duplicate()) 2180 } 2181 2182 pub fun check(): Bool { 2183 let r <- create self.r.duplicate() 2184 let c = r.check() 2185 destroy r 2186 return c 2187 } 2188 2189 destroy(){ 2190 pre { 2191 self.check() 2192 } 2193 destroy self.r 2194 } 2195 } 2196 pub resource Resource84 { 2197 pub let c: UInt64 2198 pub let r: @Resource85 2199 2200 init(_ r: @Resource85) { 2201 self.c = UInt64(1.0) 2202 self.r <- r 2203 } 2204 pub fun duplicate(): @Resource84{ 2205 return <- create Resource84(<-self.r.duplicate()) 2206 } 2207 2208 pub fun check(): Bool { 2209 let r <- create self.r.duplicate() 2210 let c = r.check() 2211 destroy r 2212 return c 2213 } 2214 2215 destroy(){ 2216 pre { 2217 self.check() 2218 } 2219 destroy self.r 2220 } 2221 } 2222 pub resource Resource85 { 2223 pub let c: UInt64 2224 pub let r: @Resource86 2225 2226 init(_ r: @Resource86) { 2227 self.c = UInt64(1.0) 2228 self.r <- r 2229 } 2230 pub fun duplicate(): @Resource85{ 2231 return <- create Resource85(<-self.r.duplicate()) 2232 } 2233 2234 pub fun check(): Bool { 2235 let r <- create self.r.duplicate() 2236 let c = r.check() 2237 destroy r 2238 return c 2239 } 2240 2241 destroy(){ 2242 pre { 2243 self.check() 2244 } 2245 destroy self.r 2246 } 2247 } 2248 pub resource Resource86 { 2249 pub let c: UInt64 2250 pub let r: @Resource87 2251 2252 init(_ r: @Resource87) { 2253 self.c = UInt64(1.0) 2254 self.r <- r 2255 } 2256 pub fun duplicate(): @Resource86{ 2257 return <- create Resource86(<-self.r.duplicate()) 2258 } 2259 2260 pub fun check(): Bool { 2261 let r <- create self.r.duplicate() 2262 let c = r.check() 2263 destroy r 2264 return c 2265 } 2266 2267 destroy(){ 2268 pre { 2269 self.check() 2270 } 2271 destroy self.r 2272 } 2273 } 2274 pub resource Resource87 { 2275 pub let c: UInt64 2276 pub let r: @Resource88 2277 2278 init(_ r: @Resource88) { 2279 self.c = UInt64(1.0) 2280 self.r <- r 2281 } 2282 pub fun duplicate(): @Resource87{ 2283 return <- create Resource87(<-self.r.duplicate()) 2284 } 2285 2286 pub fun check(): Bool { 2287 let r <- create self.r.duplicate() 2288 let c = r.check() 2289 destroy r 2290 return c 2291 } 2292 2293 destroy(){ 2294 pre { 2295 self.check() 2296 } 2297 destroy self.r 2298 } 2299 } 2300 pub resource Resource88 { 2301 pub let c: UInt64 2302 pub let r: @Resource89 2303 2304 init(_ r: @Resource89) { 2305 self.c = UInt64(1.0) 2306 self.r <- r 2307 } 2308 pub fun duplicate(): @Resource88{ 2309 return <- create Resource88(<-self.r.duplicate()) 2310 } 2311 2312 pub fun check(): Bool { 2313 let r <- create self.r.duplicate() 2314 let c = r.check() 2315 destroy r 2316 return c 2317 } 2318 2319 destroy(){ 2320 pre { 2321 self.check() 2322 } 2323 destroy self.r 2324 } 2325 } 2326 pub resource Resource89 { 2327 pub let c: UInt64 2328 pub let r: @Resource90 2329 2330 init(_ r: @Resource90) { 2331 self.c = UInt64(1.0) 2332 self.r <- r 2333 } 2334 pub fun duplicate(): @Resource89{ 2335 return <- create Resource89(<-self.r.duplicate()) 2336 } 2337 2338 pub fun check(): Bool { 2339 let r <- create self.r.duplicate() 2340 let c = r.check() 2341 destroy r 2342 return c 2343 } 2344 2345 destroy(){ 2346 pre { 2347 self.check() 2348 } 2349 destroy self.r 2350 } 2351 } 2352 pub resource Resource90 { 2353 pub let c: UInt64 2354 pub let r: @Resource91 2355 2356 init(_ r: @Resource91) { 2357 self.c = UInt64(1.0) 2358 self.r <- r 2359 } 2360 pub fun duplicate(): @Resource90{ 2361 return <- create Resource90(<-self.r.duplicate()) 2362 } 2363 2364 pub fun check(): Bool { 2365 let r <- create self.r.duplicate() 2366 let c = r.check() 2367 destroy r 2368 return c 2369 } 2370 2371 destroy(){ 2372 pre { 2373 self.check() 2374 } 2375 destroy self.r 2376 } 2377 } 2378 pub resource Resource91 { 2379 pub let c: UInt64 2380 pub let r: @Resource92 2381 2382 init(_ r: @Resource92) { 2383 self.c = UInt64(1.0) 2384 self.r <- r 2385 } 2386 pub fun duplicate(): @Resource91{ 2387 return <- create Resource91(<-self.r.duplicate()) 2388 } 2389 2390 pub fun check(): Bool { 2391 let r <- create self.r.duplicate() 2392 let c = r.check() 2393 destroy r 2394 return c 2395 } 2396 2397 destroy(){ 2398 pre { 2399 self.check() 2400 } 2401 destroy self.r 2402 } 2403 } 2404 pub resource Resource92 { 2405 pub let c: UInt64 2406 pub let r: @Resource93 2407 2408 init(_ r: @Resource93) { 2409 self.c = UInt64(1.0) 2410 self.r <- r 2411 } 2412 pub fun duplicate(): @Resource92{ 2413 return <- create Resource92(<-self.r.duplicate()) 2414 } 2415 2416 pub fun check(): Bool { 2417 let r <- create self.r.duplicate() 2418 let c = r.check() 2419 destroy r 2420 return c 2421 } 2422 2423 destroy(){ 2424 pre { 2425 self.check() 2426 } 2427 destroy self.r 2428 } 2429 } 2430 pub resource Resource93 { 2431 pub let c: UInt64 2432 pub let r: @Resource94 2433 2434 init(_ r: @Resource94) { 2435 self.c = UInt64(1.0) 2436 self.r <- r 2437 } 2438 pub fun duplicate(): @Resource93{ 2439 return <- create Resource93(<-self.r.duplicate()) 2440 } 2441 2442 pub fun check(): Bool { 2443 let r <- create self.r.duplicate() 2444 let c = r.check() 2445 destroy r 2446 return c 2447 } 2448 2449 destroy(){ 2450 pre { 2451 self.check() 2452 } 2453 destroy self.r 2454 } 2455 } 2456 pub resource Resource94 { 2457 pub let c: UInt64 2458 pub let r: @Resource95 2459 2460 init(_ r: @Resource95) { 2461 self.c = UInt64(1.0) 2462 self.r <- r 2463 } 2464 pub fun duplicate(): @Resource94{ 2465 return <- create Resource94(<-self.r.duplicate()) 2466 } 2467 2468 pub fun check(): Bool { 2469 let r <- create self.r.duplicate() 2470 let c = r.check() 2471 destroy r 2472 return c 2473 } 2474 2475 destroy(){ 2476 pre { 2477 self.check() 2478 } 2479 destroy self.r 2480 } 2481 } 2482 pub resource Resource95 { 2483 pub let c: UInt64 2484 pub let r: @Resource96 2485 2486 init(_ r: @Resource96) { 2487 self.c = UInt64(1.0) 2488 self.r <- r 2489 } 2490 pub fun duplicate(): @Resource95{ 2491 return <- create Resource95(<-self.r.duplicate()) 2492 } 2493 2494 pub fun check(): Bool { 2495 let r <- create self.r.duplicate() 2496 let c = r.check() 2497 destroy r 2498 return c 2499 } 2500 2501 destroy(){ 2502 pre { 2503 self.check() 2504 } 2505 destroy self.r 2506 } 2507 } 2508 pub resource Resource96 { 2509 pub let c: UInt64 2510 pub let r: @Resource97 2511 2512 init(_ r: @Resource97) { 2513 self.c = UInt64(1.0) 2514 self.r <- r 2515 } 2516 pub fun duplicate(): @Resource96{ 2517 return <- create Resource96(<-self.r.duplicate()) 2518 } 2519 2520 pub fun check(): Bool { 2521 let r <- create self.r.duplicate() 2522 let c = r.check() 2523 destroy r 2524 return c 2525 } 2526 2527 destroy(){ 2528 pre { 2529 self.check() 2530 } 2531 destroy self.r 2532 } 2533 } 2534 pub resource Resource97 { 2535 pub let c: UInt64 2536 pub let r: @Resource98 2537 2538 init(_ r: @Resource98) { 2539 self.c = UInt64(1.0) 2540 self.r <- r 2541 } 2542 pub fun duplicate(): @Resource97{ 2543 return <- create Resource97(<-self.r.duplicate()) 2544 } 2545 2546 pub fun check(): Bool { 2547 let r <- create self.r.duplicate() 2548 let c = r.check() 2549 destroy r 2550 return c 2551 } 2552 2553 destroy(){ 2554 pre { 2555 self.check() 2556 } 2557 destroy self.r 2558 } 2559 } 2560 pub resource Resource98 { 2561 pub let c: UInt64 2562 pub let r: @Resource99 2563 2564 init(_ r: @Resource99) { 2565 self.c = UInt64(1.0) 2566 self.r <- r 2567 } 2568 pub fun duplicate(): @Resource98{ 2569 return <- create Resource98(<-self.r.duplicate()) 2570 } 2571 2572 pub fun check(): Bool { 2573 let r <- create self.r.duplicate() 2574 let c = r.check() 2575 destroy r 2576 return c 2577 } 2578 2579 destroy(){ 2580 pre { 2581 self.check() 2582 } 2583 destroy self.r 2584 } 2585 } 2586 pub resource Resource99 { 2587 pub let c: UInt64 2588 pub let r: @Resource100 2589 2590 init(_ r: @Resource100) { 2591 self.c = UInt64(1.0) 2592 self.r <- r 2593 } 2594 pub fun duplicate(): @Resource99{ 2595 return <- create Resource99(<-self.r.duplicate()) 2596 } 2597 2598 pub fun check(): Bool { 2599 let r <- create self.r.duplicate() 2600 let c = r.check() 2601 destroy r 2602 return c 2603 } 2604 2605 destroy(){ 2606 pre { 2607 self.check() 2608 } 2609 destroy self.r 2610 } 2611 } 2612 pub resource Resource100 { 2613 pub let c: UInt64 2614 pub let r: @Resource101 2615 2616 init(_ r: @Resource101) { 2617 self.c = UInt64(1.0) 2618 self.r <- r 2619 } 2620 pub fun duplicate(): @Resource100{ 2621 return <- create Resource100(<-self.r.duplicate()) 2622 } 2623 2624 pub fun check(): Bool { 2625 let r <- create self.r.duplicate() 2626 let c = r.check() 2627 destroy r 2628 return c 2629 } 2630 2631 destroy(){ 2632 pre { 2633 self.check() 2634 } 2635 destroy self.r 2636 } 2637 } 2638 pub resource Resource101 { 2639 pub let c: UInt64 2640 pub let r: @Resource102 2641 2642 init(_ r: @Resource102) { 2643 self.c = UInt64(1.0) 2644 self.r <- r 2645 } 2646 pub fun duplicate(): @Resource101{ 2647 return <- create Resource101(<-self.r.duplicate()) 2648 } 2649 2650 pub fun check(): Bool { 2651 let r <- create self.r.duplicate() 2652 let c = r.check() 2653 destroy r 2654 return c 2655 } 2656 2657 destroy(){ 2658 pre { 2659 self.check() 2660 } 2661 destroy self.r 2662 } 2663 } 2664 pub resource Resource102 { 2665 pub let c: UInt64 2666 pub let r: @Resource103 2667 2668 init(_ r: @Resource103) { 2669 self.c = UInt64(1.0) 2670 self.r <- r 2671 } 2672 pub fun duplicate(): @Resource102{ 2673 return <- create Resource102(<-self.r.duplicate()) 2674 } 2675 2676 pub fun check(): Bool { 2677 let r <- create self.r.duplicate() 2678 let c = r.check() 2679 destroy r 2680 return c 2681 } 2682 2683 destroy(){ 2684 pre { 2685 self.check() 2686 } 2687 destroy self.r 2688 } 2689 } 2690 pub resource Resource103 { 2691 pub let c: UInt64 2692 pub let r: @Resource104 2693 2694 init(_ r: @Resource104) { 2695 self.c = UInt64(1.0) 2696 self.r <- r 2697 } 2698 pub fun duplicate(): @Resource103{ 2699 return <- create Resource103(<-self.r.duplicate()) 2700 } 2701 2702 pub fun check(): Bool { 2703 let r <- create self.r.duplicate() 2704 let c = r.check() 2705 destroy r 2706 return c 2707 } 2708 2709 destroy(){ 2710 pre { 2711 self.check() 2712 } 2713 destroy self.r 2714 } 2715 } 2716 pub resource Resource104 { 2717 pub let c: UInt64 2718 pub let r: @Resource105 2719 2720 init(_ r: @Resource105) { 2721 self.c = UInt64(1.0) 2722 self.r <- r 2723 } 2724 pub fun duplicate(): @Resource104{ 2725 return <- create Resource104(<-self.r.duplicate()) 2726 } 2727 2728 pub fun check(): Bool { 2729 let r <- create self.r.duplicate() 2730 let c = r.check() 2731 destroy r 2732 return c 2733 } 2734 2735 destroy(){ 2736 pre { 2737 self.check() 2738 } 2739 destroy self.r 2740 } 2741 } 2742 pub resource Resource105 { 2743 pub let c: UInt64 2744 pub let r: @Resource106 2745 2746 init(_ r: @Resource106) { 2747 self.c = UInt64(1.0) 2748 self.r <- r 2749 } 2750 pub fun duplicate(): @Resource105{ 2751 return <- create Resource105(<-self.r.duplicate()) 2752 } 2753 2754 pub fun check(): Bool { 2755 let r <- create self.r.duplicate() 2756 let c = r.check() 2757 destroy r 2758 return c 2759 } 2760 2761 destroy(){ 2762 pre { 2763 self.check() 2764 } 2765 destroy self.r 2766 } 2767 } 2768 pub resource Resource106 { 2769 pub let c: UInt64 2770 pub let r: @Resource107 2771 2772 init(_ r: @Resource107) { 2773 self.c = UInt64(1.0) 2774 self.r <- r 2775 } 2776 pub fun duplicate(): @Resource106{ 2777 return <- create Resource106(<-self.r.duplicate()) 2778 } 2779 2780 pub fun check(): Bool { 2781 let r <- create self.r.duplicate() 2782 let c = r.check() 2783 destroy r 2784 return c 2785 } 2786 2787 destroy(){ 2788 pre { 2789 self.check() 2790 } 2791 destroy self.r 2792 } 2793 } 2794 pub resource Resource107 { 2795 pub let c: UInt64 2796 pub let r: @Resource108 2797 2798 init(_ r: @Resource108) { 2799 self.c = UInt64(1.0) 2800 self.r <- r 2801 } 2802 pub fun duplicate(): @Resource107{ 2803 return <- create Resource107(<-self.r.duplicate()) 2804 } 2805 2806 pub fun check(): Bool { 2807 let r <- create self.r.duplicate() 2808 let c = r.check() 2809 destroy r 2810 return c 2811 } 2812 2813 destroy(){ 2814 pre { 2815 self.check() 2816 } 2817 destroy self.r 2818 } 2819 } 2820 pub resource Resource108 { 2821 pub let c: UInt64 2822 pub let r: @Resource109 2823 2824 init(_ r: @Resource109) { 2825 self.c = UInt64(1.0) 2826 self.r <- r 2827 } 2828 pub fun duplicate(): @Resource108{ 2829 return <- create Resource108(<-self.r.duplicate()) 2830 } 2831 2832 pub fun check(): Bool { 2833 let r <- create self.r.duplicate() 2834 let c = r.check() 2835 destroy r 2836 return c 2837 } 2838 2839 destroy(){ 2840 pre { 2841 self.check() 2842 } 2843 destroy self.r 2844 } 2845 } 2846 pub resource Resource109 { 2847 pub let c: UInt64 2848 pub let r: @Resource110 2849 2850 init(_ r: @Resource110) { 2851 self.c = UInt64(1.0) 2852 self.r <- r 2853 } 2854 pub fun duplicate(): @Resource109{ 2855 return <- create Resource109(<-self.r.duplicate()) 2856 } 2857 2858 pub fun check(): Bool { 2859 let r <- create self.r.duplicate() 2860 let c = r.check() 2861 destroy r 2862 return c 2863 } 2864 2865 destroy(){ 2866 pre { 2867 self.check() 2868 } 2869 destroy self.r 2870 } 2871 } 2872 pub resource Resource110 { 2873 pub let c: UInt64 2874 pub let r: @Resource111 2875 2876 init(_ r: @Resource111) { 2877 self.c = UInt64(1.0) 2878 self.r <- r 2879 } 2880 pub fun duplicate(): @Resource110{ 2881 return <- create Resource110(<-self.r.duplicate()) 2882 } 2883 2884 pub fun check(): Bool { 2885 let r <- create self.r.duplicate() 2886 let c = r.check() 2887 destroy r 2888 return c 2889 } 2890 2891 destroy(){ 2892 pre { 2893 self.check() 2894 } 2895 destroy self.r 2896 } 2897 } 2898 pub resource Resource111 { 2899 pub let c: UInt64 2900 pub let r: @Resource112 2901 2902 init(_ r: @Resource112) { 2903 self.c = UInt64(1.0) 2904 self.r <- r 2905 } 2906 pub fun duplicate(): @Resource111{ 2907 return <- create Resource111(<-self.r.duplicate()) 2908 } 2909 2910 pub fun check(): Bool { 2911 let r <- create self.r.duplicate() 2912 let c = r.check() 2913 destroy r 2914 return c 2915 } 2916 2917 destroy(){ 2918 pre { 2919 self.check() 2920 } 2921 destroy self.r 2922 } 2923 } 2924 pub resource Resource112 { 2925 pub let c: UInt64 2926 pub let r: @Resource113 2927 2928 init(_ r: @Resource113) { 2929 self.c = UInt64(1.0) 2930 self.r <- r 2931 } 2932 pub fun duplicate(): @Resource112{ 2933 return <- create Resource112(<-self.r.duplicate()) 2934 } 2935 2936 pub fun check(): Bool { 2937 let r <- create self.r.duplicate() 2938 let c = r.check() 2939 destroy r 2940 return c 2941 } 2942 2943 destroy(){ 2944 pre { 2945 self.check() 2946 } 2947 destroy self.r 2948 } 2949 } 2950 pub resource Resource113 { 2951 pub let c: UInt64 2952 pub let r: @Resource114 2953 2954 init(_ r: @Resource114) { 2955 self.c = UInt64(1.0) 2956 self.r <- r 2957 } 2958 pub fun duplicate(): @Resource113{ 2959 return <- create Resource113(<-self.r.duplicate()) 2960 } 2961 2962 pub fun check(): Bool { 2963 let r <- create self.r.duplicate() 2964 let c = r.check() 2965 destroy r 2966 return c 2967 } 2968 2969 destroy(){ 2970 pre { 2971 self.check() 2972 } 2973 destroy self.r 2974 } 2975 } 2976 pub resource Resource114 { 2977 pub let c: UInt64 2978 pub let r: @Resource115 2979 2980 init(_ r: @Resource115) { 2981 self.c = UInt64(1.0) 2982 self.r <- r 2983 } 2984 pub fun duplicate(): @Resource114{ 2985 return <- create Resource114(<-self.r.duplicate()) 2986 } 2987 2988 pub fun check(): Bool { 2989 let r <- create self.r.duplicate() 2990 let c = r.check() 2991 destroy r 2992 return c 2993 } 2994 2995 destroy(){ 2996 pre { 2997 self.check() 2998 } 2999 destroy self.r 3000 } 3001 } 3002 pub resource Resource115 { 3003 pub let c: UInt64 3004 pub let r: @Resource116 3005 3006 init(_ r: @Resource116) { 3007 self.c = UInt64(1.0) 3008 self.r <- r 3009 } 3010 pub fun duplicate(): @Resource115{ 3011 return <- create Resource115(<-self.r.duplicate()) 3012 } 3013 3014 pub fun check(): Bool { 3015 let r <- create self.r.duplicate() 3016 let c = r.check() 3017 destroy r 3018 return c 3019 } 3020 3021 destroy(){ 3022 pre { 3023 self.check() 3024 } 3025 destroy self.r 3026 } 3027 } 3028 pub resource Resource116 { 3029 pub let c: UInt64 3030 pub let r: @Resource117 3031 3032 init(_ r: @Resource117) { 3033 self.c = UInt64(1.0) 3034 self.r <- r 3035 } 3036 pub fun duplicate(): @Resource116{ 3037 return <- create Resource116(<-self.r.duplicate()) 3038 } 3039 3040 pub fun check(): Bool { 3041 let r <- create self.r.duplicate() 3042 let c = r.check() 3043 destroy r 3044 return c 3045 } 3046 3047 destroy(){ 3048 pre { 3049 self.check() 3050 } 3051 destroy self.r 3052 } 3053 } 3054 pub resource Resource117 { 3055 pub let c: UInt64 3056 pub let r: @Resource118 3057 3058 init(_ r: @Resource118) { 3059 self.c = UInt64(1.0) 3060 self.r <- r 3061 } 3062 pub fun duplicate(): @Resource117{ 3063 return <- create Resource117(<-self.r.duplicate()) 3064 } 3065 3066 pub fun check(): Bool { 3067 let r <- create self.r.duplicate() 3068 let c = r.check() 3069 destroy r 3070 return c 3071 } 3072 3073 destroy(){ 3074 pre { 3075 self.check() 3076 } 3077 destroy self.r 3078 } 3079 } 3080 pub resource Resource118 { 3081 pub let c: UInt64 3082 pub let r: @Resource119 3083 3084 init(_ r: @Resource119) { 3085 self.c = UInt64(1.0) 3086 self.r <- r 3087 } 3088 pub fun duplicate(): @Resource118{ 3089 return <- create Resource118(<-self.r.duplicate()) 3090 } 3091 3092 pub fun check(): Bool { 3093 let r <- create self.r.duplicate() 3094 let c = r.check() 3095 destroy r 3096 return c 3097 } 3098 3099 destroy(){ 3100 pre { 3101 self.check() 3102 } 3103 destroy self.r 3104 } 3105 } 3106 pub resource Resource119 { 3107 pub let c: UInt64 3108 pub let r: @Resource120 3109 3110 init(_ r: @Resource120) { 3111 self.c = UInt64(1.0) 3112 self.r <- r 3113 } 3114 pub fun duplicate(): @Resource119{ 3115 return <- create Resource119(<-self.r.duplicate()) 3116 } 3117 3118 pub fun check(): Bool { 3119 let r <- create self.r.duplicate() 3120 let c = r.check() 3121 destroy r 3122 return c 3123 } 3124 3125 destroy(){ 3126 pre { 3127 self.check() 3128 } 3129 destroy self.r 3130 } 3131 } 3132 pub resource Resource120 { 3133 pub let c: UInt64 3134 pub let r: @Resource121 3135 3136 init(_ r: @Resource121) { 3137 self.c = UInt64(1.0) 3138 self.r <- r 3139 } 3140 pub fun duplicate(): @Resource120{ 3141 return <- create Resource120(<-self.r.duplicate()) 3142 } 3143 3144 pub fun check(): Bool { 3145 let r <- create self.r.duplicate() 3146 let c = r.check() 3147 destroy r 3148 return c 3149 } 3150 3151 destroy(){ 3152 pre { 3153 self.check() 3154 } 3155 destroy self.r 3156 } 3157 } 3158 pub resource Resource121 { 3159 pub let c: UInt64 3160 pub let r: @Resource122 3161 3162 init(_ r: @Resource122) { 3163 self.c = UInt64(1.0) 3164 self.r <- r 3165 } 3166 pub fun duplicate(): @Resource121{ 3167 return <- create Resource121(<-self.r.duplicate()) 3168 } 3169 3170 pub fun check(): Bool { 3171 let r <- create self.r.duplicate() 3172 let c = r.check() 3173 destroy r 3174 return c 3175 } 3176 3177 destroy(){ 3178 pre { 3179 self.check() 3180 } 3181 destroy self.r 3182 } 3183 } 3184 pub resource Resource122 { 3185 pub let c: UInt64 3186 pub let r: @Resource123 3187 3188 init(_ r: @Resource123) { 3189 self.c = UInt64(1.0) 3190 self.r <- r 3191 } 3192 pub fun duplicate(): @Resource122{ 3193 return <- create Resource122(<-self.r.duplicate()) 3194 } 3195 3196 pub fun check(): Bool { 3197 let r <- create self.r.duplicate() 3198 let c = r.check() 3199 destroy r 3200 return c 3201 } 3202 3203 destroy(){ 3204 pre { 3205 self.check() 3206 } 3207 destroy self.r 3208 } 3209 } 3210 pub resource Resource123 { 3211 pub let c: UInt64 3212 pub let r: @Resource124 3213 3214 init(_ r: @Resource124) { 3215 self.c = UInt64(1.0) 3216 self.r <- r 3217 } 3218 pub fun duplicate(): @Resource123{ 3219 return <- create Resource123(<-self.r.duplicate()) 3220 } 3221 3222 pub fun check(): Bool { 3223 let r <- create self.r.duplicate() 3224 let c = r.check() 3225 destroy r 3226 return c 3227 } 3228 3229 destroy(){ 3230 pre { 3231 self.check() 3232 } 3233 destroy self.r 3234 } 3235 } 3236 pub resource Resource124 { 3237 pub let c: UInt64 3238 pub let r: @Resource125 3239 3240 init(_ r: @Resource125) { 3241 self.c = UInt64(1.0) 3242 self.r <- r 3243 } 3244 pub fun duplicate(): @Resource124{ 3245 return <- create Resource124(<-self.r.duplicate()) 3246 } 3247 3248 pub fun check(): Bool { 3249 let r <- create self.r.duplicate() 3250 let c = r.check() 3251 destroy r 3252 return c 3253 } 3254 3255 destroy(){ 3256 pre { 3257 self.check() 3258 } 3259 destroy self.r 3260 } 3261 } 3262 pub resource Resource125 { 3263 pub let c: UInt64 3264 pub let r: @Resource126 3265 3266 init(_ r: @Resource126) { 3267 self.c = UInt64(1.0) 3268 self.r <- r 3269 } 3270 pub fun duplicate(): @Resource125{ 3271 return <- create Resource125(<-self.r.duplicate()) 3272 } 3273 3274 pub fun check(): Bool { 3275 let r <- create self.r.duplicate() 3276 let c = r.check() 3277 destroy r 3278 return c 3279 } 3280 3281 destroy(){ 3282 pre { 3283 self.check() 3284 } 3285 destroy self.r 3286 } 3287 } 3288 pub resource Resource126 { 3289 pub let c: UInt64 3290 pub let r: @Resource127 3291 3292 init(_ r: @Resource127) { 3293 self.c = UInt64(1.0) 3294 self.r <- r 3295 } 3296 pub fun duplicate(): @Resource126{ 3297 return <- create Resource126(<-self.r.duplicate()) 3298 } 3299 3300 pub fun check(): Bool { 3301 let r <- create self.r.duplicate() 3302 let c = r.check() 3303 destroy r 3304 return c 3305 } 3306 3307 destroy(){ 3308 pre { 3309 self.check() 3310 } 3311 destroy self.r 3312 } 3313 } 3314 pub resource Resource127 { 3315 pub let c: UInt64 3316 pub let r: @Resource128 3317 3318 init(_ r: @Resource128) { 3319 self.c = UInt64(1.0) 3320 self.r <- r 3321 } 3322 pub fun duplicate(): @Resource127{ 3323 return <- create Resource127(<-self.r.duplicate()) 3324 } 3325 3326 pub fun check(): Bool { 3327 let r <- create self.r.duplicate() 3328 let c = r.check() 3329 destroy r 3330 return c 3331 } 3332 3333 destroy(){ 3334 pre { 3335 self.check() 3336 } 3337 destroy self.r 3338 } 3339 } 3340 pub resource Resource128 { 3341 pub let c: UInt64 3342 pub let r: @Resource129 3343 3344 init(_ r: @Resource129) { 3345 self.c = UInt64(1.0) 3346 self.r <- r 3347 } 3348 pub fun duplicate(): @Resource128{ 3349 return <- create Resource128(<-self.r.duplicate()) 3350 } 3351 3352 pub fun check(): Bool { 3353 let r <- create self.r.duplicate() 3354 let c = r.check() 3355 destroy r 3356 return c 3357 } 3358 3359 destroy(){ 3360 pre { 3361 self.check() 3362 } 3363 destroy self.r 3364 } 3365 } 3366 pub resource Resource129 { 3367 pub let c: UInt64 3368 pub let r: @Resource130 3369 3370 init(_ r: @Resource130) { 3371 self.c = UInt64(1.0) 3372 self.r <- r 3373 } 3374 pub fun duplicate(): @Resource129{ 3375 return <- create Resource129(<-self.r.duplicate()) 3376 } 3377 3378 pub fun check(): Bool { 3379 let r <- create self.r.duplicate() 3380 let c = r.check() 3381 destroy r 3382 return c 3383 } 3384 3385 destroy(){ 3386 pre { 3387 self.check() 3388 } 3389 destroy self.r 3390 } 3391 } 3392 pub resource Resource130 { 3393 pub let c: UInt64 3394 pub let r: @Resource131 3395 3396 init(_ r: @Resource131) { 3397 self.c = UInt64(1.0) 3398 self.r <- r 3399 } 3400 pub fun duplicate(): @Resource130{ 3401 return <- create Resource130(<-self.r.duplicate()) 3402 } 3403 3404 pub fun check(): Bool { 3405 let r <- create self.r.duplicate() 3406 let c = r.check() 3407 destroy r 3408 return c 3409 } 3410 3411 destroy(){ 3412 pre { 3413 self.check() 3414 } 3415 destroy self.r 3416 } 3417 } 3418 pub resource Resource131 { 3419 pub let c: UInt64 3420 pub let r: @Resource132 3421 3422 init(_ r: @Resource132) { 3423 self.c = UInt64(1.0) 3424 self.r <- r 3425 } 3426 pub fun duplicate(): @Resource131{ 3427 return <- create Resource131(<-self.r.duplicate()) 3428 } 3429 3430 pub fun check(): Bool { 3431 let r <- create self.r.duplicate() 3432 let c = r.check() 3433 destroy r 3434 return c 3435 } 3436 3437 destroy(){ 3438 pre { 3439 self.check() 3440 } 3441 destroy self.r 3442 } 3443 } 3444 pub resource Resource132 { 3445 pub let c: UInt64 3446 pub let r: @Resource133 3447 3448 init(_ r: @Resource133) { 3449 self.c = UInt64(1.0) 3450 self.r <- r 3451 } 3452 pub fun duplicate(): @Resource132{ 3453 return <- create Resource132(<-self.r.duplicate()) 3454 } 3455 3456 pub fun check(): Bool { 3457 let r <- create self.r.duplicate() 3458 let c = r.check() 3459 destroy r 3460 return c 3461 } 3462 3463 destroy(){ 3464 pre { 3465 self.check() 3466 } 3467 destroy self.r 3468 } 3469 } 3470 pub resource Resource133 { 3471 pub let c: UInt64 3472 pub let r: @Resource134 3473 3474 init(_ r: @Resource134) { 3475 self.c = UInt64(1.0) 3476 self.r <- r 3477 } 3478 pub fun duplicate(): @Resource133{ 3479 return <- create Resource133(<-self.r.duplicate()) 3480 } 3481 3482 pub fun check(): Bool { 3483 let r <- create self.r.duplicate() 3484 let c = r.check() 3485 destroy r 3486 return c 3487 } 3488 3489 destroy(){ 3490 pre { 3491 self.check() 3492 } 3493 destroy self.r 3494 } 3495 } 3496 pub resource Resource134 { 3497 pub let c: UInt64 3498 pub let r: @Resource135 3499 3500 init(_ r: @Resource135) { 3501 self.c = UInt64(1.0) 3502 self.r <- r 3503 } 3504 pub fun duplicate(): @Resource134{ 3505 return <- create Resource134(<-self.r.duplicate()) 3506 } 3507 3508 pub fun check(): Bool { 3509 let r <- create self.r.duplicate() 3510 let c = r.check() 3511 destroy r 3512 return c 3513 } 3514 3515 destroy(){ 3516 pre { 3517 self.check() 3518 } 3519 destroy self.r 3520 } 3521 } 3522 pub resource Resource135 { 3523 pub let c: UInt64 3524 pub let r: @Resource136 3525 3526 init(_ r: @Resource136) { 3527 self.c = UInt64(1.0) 3528 self.r <- r 3529 } 3530 pub fun duplicate(): @Resource135{ 3531 return <- create Resource135(<-self.r.duplicate()) 3532 } 3533 3534 pub fun check(): Bool { 3535 let r <- create self.r.duplicate() 3536 let c = r.check() 3537 destroy r 3538 return c 3539 } 3540 3541 destroy(){ 3542 pre { 3543 self.check() 3544 } 3545 destroy self.r 3546 } 3547 } 3548 pub resource Resource136 { 3549 pub let c: UInt64 3550 pub let r: @Resource137 3551 3552 init(_ r: @Resource137) { 3553 self.c = UInt64(1.0) 3554 self.r <- r 3555 } 3556 pub fun duplicate(): @Resource136{ 3557 return <- create Resource136(<-self.r.duplicate()) 3558 } 3559 3560 pub fun check(): Bool { 3561 let r <- create self.r.duplicate() 3562 let c = r.check() 3563 destroy r 3564 return c 3565 } 3566 3567 destroy(){ 3568 pre { 3569 self.check() 3570 } 3571 destroy self.r 3572 } 3573 } 3574 pub resource Resource137 { 3575 pub let c: UInt64 3576 pub let r: @Resource138 3577 3578 init(_ r: @Resource138) { 3579 self.c = UInt64(1.0) 3580 self.r <- r 3581 } 3582 pub fun duplicate(): @Resource137{ 3583 return <- create Resource137(<-self.r.duplicate()) 3584 } 3585 3586 pub fun check(): Bool { 3587 let r <- create self.r.duplicate() 3588 let c = r.check() 3589 destroy r 3590 return c 3591 } 3592 3593 destroy(){ 3594 pre { 3595 self.check() 3596 } 3597 destroy self.r 3598 } 3599 } 3600 pub resource Resource138 { 3601 pub let c: UInt64 3602 pub let r: @Resource139 3603 3604 init(_ r: @Resource139) { 3605 self.c = UInt64(1.0) 3606 self.r <- r 3607 } 3608 pub fun duplicate(): @Resource138{ 3609 return <- create Resource138(<-self.r.duplicate()) 3610 } 3611 3612 pub fun check(): Bool { 3613 let r <- create self.r.duplicate() 3614 let c = r.check() 3615 destroy r 3616 return c 3617 } 3618 3619 destroy(){ 3620 pre { 3621 self.check() 3622 } 3623 destroy self.r 3624 } 3625 } 3626 pub resource Resource139 { 3627 pub let c: UInt64 3628 pub let r: @Resource140 3629 3630 init(_ r: @Resource140) { 3631 self.c = UInt64(1.0) 3632 self.r <- r 3633 } 3634 pub fun duplicate(): @Resource139{ 3635 return <- create Resource139(<-self.r.duplicate()) 3636 } 3637 3638 pub fun check(): Bool { 3639 let r <- create self.r.duplicate() 3640 let c = r.check() 3641 destroy r 3642 return c 3643 } 3644 3645 destroy(){ 3646 pre { 3647 self.check() 3648 } 3649 destroy self.r 3650 } 3651 } 3652 pub resource Resource140 { 3653 pub let c: UInt64 3654 pub let r: @Resource141 3655 3656 init(_ r: @Resource141) { 3657 self.c = UInt64(1.0) 3658 self.r <- r 3659 } 3660 pub fun duplicate(): @Resource140{ 3661 return <- create Resource140(<-self.r.duplicate()) 3662 } 3663 3664 pub fun check(): Bool { 3665 let r <- create self.r.duplicate() 3666 let c = r.check() 3667 destroy r 3668 return c 3669 } 3670 3671 destroy(){ 3672 pre { 3673 self.check() 3674 } 3675 destroy self.r 3676 } 3677 } 3678 pub resource Resource141 { 3679 pub let c: UInt64 3680 pub let r: @Resource142 3681 3682 init(_ r: @Resource142) { 3683 self.c = UInt64(1.0) 3684 self.r <- r 3685 } 3686 pub fun duplicate(): @Resource141{ 3687 return <- create Resource141(<-self.r.duplicate()) 3688 } 3689 3690 pub fun check(): Bool { 3691 let r <- create self.r.duplicate() 3692 let c = r.check() 3693 destroy r 3694 return c 3695 } 3696 3697 destroy(){ 3698 pre { 3699 self.check() 3700 } 3701 destroy self.r 3702 } 3703 } 3704 pub resource Resource142 { 3705 pub let c: UInt64 3706 pub let r: @Resource143 3707 3708 init(_ r: @Resource143) { 3709 self.c = UInt64(1.0) 3710 self.r <- r 3711 } 3712 pub fun duplicate(): @Resource142{ 3713 return <- create Resource142(<-self.r.duplicate()) 3714 } 3715 3716 pub fun check(): Bool { 3717 let r <- create self.r.duplicate() 3718 let c = r.check() 3719 destroy r 3720 return c 3721 } 3722 3723 destroy(){ 3724 pre { 3725 self.check() 3726 } 3727 destroy self.r 3728 } 3729 } 3730 pub resource Resource143 { 3731 pub let c: UInt64 3732 pub let r: @Resource144 3733 3734 init(_ r: @Resource144) { 3735 self.c = UInt64(1.0) 3736 self.r <- r 3737 } 3738 pub fun duplicate(): @Resource143{ 3739 return <- create Resource143(<-self.r.duplicate()) 3740 } 3741 3742 pub fun check(): Bool { 3743 let r <- create self.r.duplicate() 3744 let c = r.check() 3745 destroy r 3746 return c 3747 } 3748 3749 destroy(){ 3750 pre { 3751 self.check() 3752 } 3753 destroy self.r 3754 } 3755 } 3756 pub resource Resource144 { 3757 pub let c: UInt64 3758 pub let r: @Resource145 3759 3760 init(_ r: @Resource145) { 3761 self.c = UInt64(1.0) 3762 self.r <- r 3763 } 3764 pub fun duplicate(): @Resource144{ 3765 return <- create Resource144(<-self.r.duplicate()) 3766 } 3767 3768 pub fun check(): Bool { 3769 let r <- create self.r.duplicate() 3770 let c = r.check() 3771 destroy r 3772 return c 3773 } 3774 3775 destroy(){ 3776 pre { 3777 self.check() 3778 } 3779 destroy self.r 3780 } 3781 } 3782 pub resource Resource145 { 3783 pub let c: UInt64 3784 pub let r: @Resource146 3785 3786 init(_ r: @Resource146) { 3787 self.c = UInt64(1.0) 3788 self.r <- r 3789 } 3790 pub fun duplicate(): @Resource145{ 3791 return <- create Resource145(<-self.r.duplicate()) 3792 } 3793 3794 pub fun check(): Bool { 3795 let r <- create self.r.duplicate() 3796 let c = r.check() 3797 destroy r 3798 return c 3799 } 3800 3801 destroy(){ 3802 pre { 3803 self.check() 3804 } 3805 destroy self.r 3806 } 3807 } 3808 pub resource Resource146 { 3809 pub let c: UInt64 3810 pub let r: @Resource147 3811 3812 init(_ r: @Resource147) { 3813 self.c = UInt64(1.0) 3814 self.r <- r 3815 } 3816 pub fun duplicate(): @Resource146{ 3817 return <- create Resource146(<-self.r.duplicate()) 3818 } 3819 3820 pub fun check(): Bool { 3821 let r <- create self.r.duplicate() 3822 let c = r.check() 3823 destroy r 3824 return c 3825 } 3826 3827 destroy(){ 3828 pre { 3829 self.check() 3830 } 3831 destroy self.r 3832 } 3833 } 3834 pub resource Resource147 { 3835 pub let c: UInt64 3836 pub let r: @Resource148 3837 3838 init(_ r: @Resource148) { 3839 self.c = UInt64(1.0) 3840 self.r <- r 3841 } 3842 pub fun duplicate(): @Resource147{ 3843 return <- create Resource147(<-self.r.duplicate()) 3844 } 3845 3846 pub fun check(): Bool { 3847 let r <- create self.r.duplicate() 3848 let c = r.check() 3849 destroy r 3850 return c 3851 } 3852 3853 destroy(){ 3854 pre { 3855 self.check() 3856 } 3857 destroy self.r 3858 } 3859 } 3860 pub resource Resource148 { 3861 pub let c: UInt64 3862 pub let r: @Resource149 3863 3864 init(_ r: @Resource149) { 3865 self.c = UInt64(1.0) 3866 self.r <- r 3867 } 3868 pub fun duplicate(): @Resource148{ 3869 return <- create Resource148(<-self.r.duplicate()) 3870 } 3871 3872 pub fun check(): Bool { 3873 let r <- create self.r.duplicate() 3874 let c = r.check() 3875 destroy r 3876 return c 3877 } 3878 3879 destroy(){ 3880 pre { 3881 self.check() 3882 } 3883 destroy self.r 3884 } 3885 } 3886 pub resource Resource149 { 3887 pub let c: UInt64 3888 pub let r: @Resource150 3889 3890 init(_ r: @Resource150) { 3891 self.c = UInt64(1.0) 3892 self.r <- r 3893 } 3894 pub fun duplicate(): @Resource149{ 3895 return <- create Resource149(<-self.r.duplicate()) 3896 } 3897 3898 pub fun check(): Bool { 3899 let r <- create self.r.duplicate() 3900 let c = r.check() 3901 destroy r 3902 return c 3903 } 3904 3905 destroy(){ 3906 pre { 3907 self.check() 3908 } 3909 destroy self.r 3910 } 3911 } 3912 pub resource Resource150 { 3913 pub let c: UInt64 3914 pub let r: @Resource151 3915 3916 init(_ r: @Resource151) { 3917 self.c = UInt64(1.0) 3918 self.r <- r 3919 } 3920 pub fun duplicate(): @Resource150{ 3921 return <- create Resource150(<-self.r.duplicate()) 3922 } 3923 3924 pub fun check(): Bool { 3925 let r <- create self.r.duplicate() 3926 let c = r.check() 3927 destroy r 3928 return c 3929 } 3930 3931 destroy(){ 3932 pre { 3933 self.check() 3934 } 3935 destroy self.r 3936 } 3937 } 3938 pub resource Resource151 { 3939 pub let c: UInt64 3940 pub let r: @Resource152 3941 3942 init(_ r: @Resource152) { 3943 self.c = UInt64(1.0) 3944 self.r <- r 3945 } 3946 pub fun duplicate(): @Resource151{ 3947 return <- create Resource151(<-self.r.duplicate()) 3948 } 3949 3950 pub fun check(): Bool { 3951 let r <- create self.r.duplicate() 3952 let c = r.check() 3953 destroy r 3954 return c 3955 } 3956 3957 destroy(){ 3958 pre { 3959 self.check() 3960 } 3961 destroy self.r 3962 } 3963 } 3964 pub resource Resource152 { 3965 pub let c: UInt64 3966 pub let r: @Resource153 3967 3968 init(_ r: @Resource153) { 3969 self.c = UInt64(1.0) 3970 self.r <- r 3971 } 3972 pub fun duplicate(): @Resource152{ 3973 return <- create Resource152(<-self.r.duplicate()) 3974 } 3975 3976 pub fun check(): Bool { 3977 let r <- create self.r.duplicate() 3978 let c = r.check() 3979 destroy r 3980 return c 3981 } 3982 3983 destroy(){ 3984 pre { 3985 self.check() 3986 } 3987 destroy self.r 3988 } 3989 } 3990 pub resource Resource153 { 3991 pub let c: UInt64 3992 pub let r: @Resource154 3993 3994 init(_ r: @Resource154) { 3995 self.c = UInt64(1.0) 3996 self.r <- r 3997 } 3998 pub fun duplicate(): @Resource153{ 3999 return <- create Resource153(<-self.r.duplicate()) 4000 } 4001 4002 pub fun check(): Bool { 4003 let r <- create self.r.duplicate() 4004 let c = r.check() 4005 destroy r 4006 return c 4007 } 4008 4009 destroy(){ 4010 pre { 4011 self.check() 4012 } 4013 destroy self.r 4014 } 4015 } 4016 pub resource Resource154 { 4017 pub let c: UInt64 4018 pub let r: @Resource155 4019 4020 init(_ r: @Resource155) { 4021 self.c = UInt64(1.0) 4022 self.r <- r 4023 } 4024 pub fun duplicate(): @Resource154{ 4025 return <- create Resource154(<-self.r.duplicate()) 4026 } 4027 4028 pub fun check(): Bool { 4029 let r <- create self.r.duplicate() 4030 let c = r.check() 4031 destroy r 4032 return c 4033 } 4034 4035 destroy(){ 4036 pre { 4037 self.check() 4038 } 4039 destroy self.r 4040 } 4041 } 4042 pub resource Resource155 { 4043 pub let c: UInt64 4044 pub let r: @Resource156 4045 4046 init(_ r: @Resource156) { 4047 self.c = UInt64(1.0) 4048 self.r <- r 4049 } 4050 pub fun duplicate(): @Resource155{ 4051 return <- create Resource155(<-self.r.duplicate()) 4052 } 4053 4054 pub fun check(): Bool { 4055 let r <- create self.r.duplicate() 4056 let c = r.check() 4057 destroy r 4058 return c 4059 } 4060 4061 destroy(){ 4062 pre { 4063 self.check() 4064 } 4065 destroy self.r 4066 } 4067 } 4068 pub resource Resource156 { 4069 pub let c: UInt64 4070 pub let r: @Resource157 4071 4072 init(_ r: @Resource157) { 4073 self.c = UInt64(1.0) 4074 self.r <- r 4075 } 4076 pub fun duplicate(): @Resource156{ 4077 return <- create Resource156(<-self.r.duplicate()) 4078 } 4079 4080 pub fun check(): Bool { 4081 let r <- create self.r.duplicate() 4082 let c = r.check() 4083 destroy r 4084 return c 4085 } 4086 4087 destroy(){ 4088 pre { 4089 self.check() 4090 } 4091 destroy self.r 4092 } 4093 } 4094 pub resource Resource157 { 4095 pub let c: UInt64 4096 pub let r: @Resource158 4097 4098 init(_ r: @Resource158) { 4099 self.c = UInt64(1.0) 4100 self.r <- r 4101 } 4102 pub fun duplicate(): @Resource157{ 4103 return <- create Resource157(<-self.r.duplicate()) 4104 } 4105 4106 pub fun check(): Bool { 4107 let r <- create self.r.duplicate() 4108 let c = r.check() 4109 destroy r 4110 return c 4111 } 4112 4113 destroy(){ 4114 pre { 4115 self.check() 4116 } 4117 destroy self.r 4118 } 4119 } 4120 pub resource Resource158 { 4121 pub let c: UInt64 4122 pub let r: @Resource159 4123 4124 init(_ r: @Resource159) { 4125 self.c = UInt64(1.0) 4126 self.r <- r 4127 } 4128 pub fun duplicate(): @Resource158{ 4129 return <- create Resource158(<-self.r.duplicate()) 4130 } 4131 4132 pub fun check(): Bool { 4133 let r <- create self.r.duplicate() 4134 let c = r.check() 4135 destroy r 4136 return c 4137 } 4138 4139 destroy(){ 4140 pre { 4141 self.check() 4142 } 4143 destroy self.r 4144 } 4145 } 4146 pub resource Resource159 { 4147 pub let c: UInt64 4148 pub let r: @Resource160 4149 4150 init(_ r: @Resource160) { 4151 self.c = UInt64(1.0) 4152 self.r <- r 4153 } 4154 pub fun duplicate(): @Resource159{ 4155 return <- create Resource159(<-self.r.duplicate()) 4156 } 4157 4158 pub fun check(): Bool { 4159 let r <- create self.r.duplicate() 4160 let c = r.check() 4161 destroy r 4162 return c 4163 } 4164 4165 destroy(){ 4166 pre { 4167 self.check() 4168 } 4169 destroy self.r 4170 } 4171 } 4172 pub resource Resource160 { 4173 pub let c: UInt64 4174 pub let r: @Resource161 4175 4176 init(_ r: @Resource161) { 4177 self.c = UInt64(1.0) 4178 self.r <- r 4179 } 4180 pub fun duplicate(): @Resource160{ 4181 return <- create Resource160(<-self.r.duplicate()) 4182 } 4183 4184 pub fun check(): Bool { 4185 let r <- create self.r.duplicate() 4186 let c = r.check() 4187 destroy r 4188 return c 4189 } 4190 4191 destroy(){ 4192 pre { 4193 self.check() 4194 } 4195 destroy self.r 4196 } 4197 } 4198 pub resource Resource161 { 4199 pub let c: UInt64 4200 pub let r: @Resource162 4201 4202 init(_ r: @Resource162) { 4203 self.c = UInt64(1.0) 4204 self.r <- r 4205 } 4206 pub fun duplicate(): @Resource161{ 4207 return <- create Resource161(<-self.r.duplicate()) 4208 } 4209 4210 pub fun check(): Bool { 4211 let r <- create self.r.duplicate() 4212 let c = r.check() 4213 destroy r 4214 return c 4215 } 4216 4217 destroy(){ 4218 pre { 4219 self.check() 4220 } 4221 destroy self.r 4222 } 4223 } 4224 pub resource Resource162 { 4225 pub let c: UInt64 4226 pub let r: @Resource163 4227 4228 init(_ r: @Resource163) { 4229 self.c = UInt64(1.0) 4230 self.r <- r 4231 } 4232 pub fun duplicate(): @Resource162{ 4233 return <- create Resource162(<-self.r.duplicate()) 4234 } 4235 4236 pub fun check(): Bool { 4237 let r <- create self.r.duplicate() 4238 let c = r.check() 4239 destroy r 4240 return c 4241 } 4242 4243 destroy(){ 4244 pre { 4245 self.check() 4246 } 4247 destroy self.r 4248 } 4249 } 4250 pub resource Resource163 { 4251 pub let c: UInt64 4252 pub let r: @Resource164 4253 4254 init(_ r: @Resource164) { 4255 self.c = UInt64(1.0) 4256 self.r <- r 4257 } 4258 pub fun duplicate(): @Resource163{ 4259 return <- create Resource163(<-self.r.duplicate()) 4260 } 4261 4262 pub fun check(): Bool { 4263 let r <- create self.r.duplicate() 4264 let c = r.check() 4265 destroy r 4266 return c 4267 } 4268 4269 destroy(){ 4270 pre { 4271 self.check() 4272 } 4273 destroy self.r 4274 } 4275 } 4276 pub resource Resource164 { 4277 pub let c: UInt64 4278 pub let r: @Resource165 4279 4280 init(_ r: @Resource165) { 4281 self.c = UInt64(1.0) 4282 self.r <- r 4283 } 4284 pub fun duplicate(): @Resource164{ 4285 return <- create Resource164(<-self.r.duplicate()) 4286 } 4287 4288 pub fun check(): Bool { 4289 let r <- create self.r.duplicate() 4290 let c = r.check() 4291 destroy r 4292 return c 4293 } 4294 4295 destroy(){ 4296 pre { 4297 self.check() 4298 } 4299 destroy self.r 4300 } 4301 } 4302 pub resource Resource165 { 4303 pub let c: UInt64 4304 pub let r: @Resource166 4305 4306 init(_ r: @Resource166) { 4307 self.c = UInt64(1.0) 4308 self.r <- r 4309 } 4310 pub fun duplicate(): @Resource165{ 4311 return <- create Resource165(<-self.r.duplicate()) 4312 } 4313 4314 pub fun check(): Bool { 4315 let r <- create self.r.duplicate() 4316 let c = r.check() 4317 destroy r 4318 return c 4319 } 4320 4321 destroy(){ 4322 pre { 4323 self.check() 4324 } 4325 destroy self.r 4326 } 4327 } 4328 pub resource Resource166 { 4329 pub let c: UInt64 4330 pub let r: @Resource167 4331 4332 init(_ r: @Resource167) { 4333 self.c = UInt64(1.0) 4334 self.r <- r 4335 } 4336 pub fun duplicate(): @Resource166{ 4337 return <- create Resource166(<-self.r.duplicate()) 4338 } 4339 4340 pub fun check(): Bool { 4341 let r <- create self.r.duplicate() 4342 let c = r.check() 4343 destroy r 4344 return c 4345 } 4346 4347 destroy(){ 4348 pre { 4349 self.check() 4350 } 4351 destroy self.r 4352 } 4353 } 4354 pub resource Resource167 { 4355 pub let c: UInt64 4356 pub let r: @Resource168 4357 4358 init(_ r: @Resource168) { 4359 self.c = UInt64(1.0) 4360 self.r <- r 4361 } 4362 pub fun duplicate(): @Resource167{ 4363 return <- create Resource167(<-self.r.duplicate()) 4364 } 4365 4366 pub fun check(): Bool { 4367 let r <- create self.r.duplicate() 4368 let c = r.check() 4369 destroy r 4370 return c 4371 } 4372 4373 destroy(){ 4374 pre { 4375 self.check() 4376 } 4377 destroy self.r 4378 } 4379 } 4380 pub resource Resource168 { 4381 pub let c: UInt64 4382 pub let r: @Resource169 4383 4384 init(_ r: @Resource169) { 4385 self.c = UInt64(1.0) 4386 self.r <- r 4387 } 4388 pub fun duplicate(): @Resource168{ 4389 return <- create Resource168(<-self.r.duplicate()) 4390 } 4391 4392 pub fun check(): Bool { 4393 let r <- create self.r.duplicate() 4394 let c = r.check() 4395 destroy r 4396 return c 4397 } 4398 4399 destroy(){ 4400 pre { 4401 self.check() 4402 } 4403 destroy self.r 4404 } 4405 } 4406 pub resource Resource169 { 4407 pub let c: UInt64 4408 pub let r: @Resource170 4409 4410 init(_ r: @Resource170) { 4411 self.c = UInt64(1.0) 4412 self.r <- r 4413 } 4414 pub fun duplicate(): @Resource169{ 4415 return <- create Resource169(<-self.r.duplicate()) 4416 } 4417 4418 pub fun check(): Bool { 4419 let r <- create self.r.duplicate() 4420 let c = r.check() 4421 destroy r 4422 return c 4423 } 4424 4425 destroy(){ 4426 pre { 4427 self.check() 4428 } 4429 destroy self.r 4430 } 4431 } 4432 pub resource Resource170 { 4433 pub let c: UInt64 4434 pub let r: @Resource171 4435 4436 init(_ r: @Resource171) { 4437 self.c = UInt64(1.0) 4438 self.r <- r 4439 } 4440 pub fun duplicate(): @Resource170{ 4441 return <- create Resource170(<-self.r.duplicate()) 4442 } 4443 4444 pub fun check(): Bool { 4445 let r <- create self.r.duplicate() 4446 let c = r.check() 4447 destroy r 4448 return c 4449 } 4450 4451 destroy(){ 4452 pre { 4453 self.check() 4454 } 4455 destroy self.r 4456 } 4457 } 4458 pub resource Resource171 { 4459 pub let c: UInt64 4460 pub let r: @Resource172 4461 4462 init(_ r: @Resource172) { 4463 self.c = UInt64(1.0) 4464 self.r <- r 4465 } 4466 pub fun duplicate(): @Resource171{ 4467 return <- create Resource171(<-self.r.duplicate()) 4468 } 4469 4470 pub fun check(): Bool { 4471 let r <- create self.r.duplicate() 4472 let c = r.check() 4473 destroy r 4474 return c 4475 } 4476 4477 destroy(){ 4478 pre { 4479 self.check() 4480 } 4481 destroy self.r 4482 } 4483 } 4484 pub resource Resource172 { 4485 pub let c: UInt64 4486 pub let r: @Resource173 4487 4488 init(_ r: @Resource173) { 4489 self.c = UInt64(1.0) 4490 self.r <- r 4491 } 4492 pub fun duplicate(): @Resource172{ 4493 return <- create Resource172(<-self.r.duplicate()) 4494 } 4495 4496 pub fun check(): Bool { 4497 let r <- create self.r.duplicate() 4498 let c = r.check() 4499 destroy r 4500 return c 4501 } 4502 4503 destroy(){ 4504 pre { 4505 self.check() 4506 } 4507 destroy self.r 4508 } 4509 } 4510 pub resource Resource173 { 4511 pub let c: UInt64 4512 pub let r: @Resource174 4513 4514 init(_ r: @Resource174) { 4515 self.c = UInt64(1.0) 4516 self.r <- r 4517 } 4518 pub fun duplicate(): @Resource173{ 4519 return <- create Resource173(<-self.r.duplicate()) 4520 } 4521 4522 pub fun check(): Bool { 4523 let r <- create self.r.duplicate() 4524 let c = r.check() 4525 destroy r 4526 return c 4527 } 4528 4529 destroy(){ 4530 pre { 4531 self.check() 4532 } 4533 destroy self.r 4534 } 4535 } 4536 pub resource Resource174 { 4537 pub let c: UInt64 4538 pub let r: @Resource175 4539 4540 init(_ r: @Resource175) { 4541 self.c = UInt64(1.0) 4542 self.r <- r 4543 } 4544 pub fun duplicate(): @Resource174{ 4545 return <- create Resource174(<-self.r.duplicate()) 4546 } 4547 4548 pub fun check(): Bool { 4549 let r <- create self.r.duplicate() 4550 let c = r.check() 4551 destroy r 4552 return c 4553 } 4554 4555 destroy(){ 4556 pre { 4557 self.check() 4558 } 4559 destroy self.r 4560 } 4561 } 4562 pub resource Resource175 { 4563 pub let c: UInt64 4564 pub let r: @Resource176 4565 4566 init(_ r: @Resource176) { 4567 self.c = UInt64(1.0) 4568 self.r <- r 4569 } 4570 pub fun duplicate(): @Resource175{ 4571 return <- create Resource175(<-self.r.duplicate()) 4572 } 4573 4574 pub fun check(): Bool { 4575 let r <- create self.r.duplicate() 4576 let c = r.check() 4577 destroy r 4578 return c 4579 } 4580 4581 destroy(){ 4582 pre { 4583 self.check() 4584 } 4585 destroy self.r 4586 } 4587 } 4588 pub resource Resource176 { 4589 pub let c: UInt64 4590 pub let r: @Resource177 4591 4592 init(_ r: @Resource177) { 4593 self.c = UInt64(1.0) 4594 self.r <- r 4595 } 4596 pub fun duplicate(): @Resource176{ 4597 return <- create Resource176(<-self.r.duplicate()) 4598 } 4599 4600 pub fun check(): Bool { 4601 let r <- create self.r.duplicate() 4602 let c = r.check() 4603 destroy r 4604 return c 4605 } 4606 4607 destroy(){ 4608 pre { 4609 self.check() 4610 } 4611 destroy self.r 4612 } 4613 } 4614 pub resource Resource177 { 4615 pub let c: UInt64 4616 pub let r: @Resource178 4617 4618 init(_ r: @Resource178) { 4619 self.c = UInt64(1.0) 4620 self.r <- r 4621 } 4622 pub fun duplicate(): @Resource177{ 4623 return <- create Resource177(<-self.r.duplicate()) 4624 } 4625 4626 pub fun check(): Bool { 4627 let r <- create self.r.duplicate() 4628 let c = r.check() 4629 destroy r 4630 return c 4631 } 4632 4633 destroy(){ 4634 pre { 4635 self.check() 4636 } 4637 destroy self.r 4638 } 4639 } 4640 pub resource Resource178 { 4641 pub let c: UInt64 4642 pub let r: @Resource179 4643 4644 init(_ r: @Resource179) { 4645 self.c = UInt64(1.0) 4646 self.r <- r 4647 } 4648 pub fun duplicate(): @Resource178{ 4649 return <- create Resource178(<-self.r.duplicate()) 4650 } 4651 4652 pub fun check(): Bool { 4653 let r <- create self.r.duplicate() 4654 let c = r.check() 4655 destroy r 4656 return c 4657 } 4658 4659 destroy(){ 4660 pre { 4661 self.check() 4662 } 4663 destroy self.r 4664 } 4665 } 4666 pub resource Resource179 { 4667 pub let c: UInt64 4668 pub let r: @Resource180 4669 4670 init(_ r: @Resource180) { 4671 self.c = UInt64(1.0) 4672 self.r <- r 4673 } 4674 pub fun duplicate(): @Resource179{ 4675 return <- create Resource179(<-self.r.duplicate()) 4676 } 4677 4678 pub fun check(): Bool { 4679 let r <- create self.r.duplicate() 4680 let c = r.check() 4681 destroy r 4682 return c 4683 } 4684 4685 destroy(){ 4686 pre { 4687 self.check() 4688 } 4689 destroy self.r 4690 } 4691 } 4692 pub resource Resource180 { 4693 pub let c: UInt64 4694 pub let r: @Resource181 4695 4696 init(_ r: @Resource181) { 4697 self.c = UInt64(1.0) 4698 self.r <- r 4699 } 4700 pub fun duplicate(): @Resource180{ 4701 return <- create Resource180(<-self.r.duplicate()) 4702 } 4703 4704 pub fun check(): Bool { 4705 let r <- create self.r.duplicate() 4706 let c = r.check() 4707 destroy r 4708 return c 4709 } 4710 4711 destroy(){ 4712 pre { 4713 self.check() 4714 } 4715 destroy self.r 4716 } 4717 } 4718 pub resource Resource181 { 4719 pub let c: UInt64 4720 pub let r: @Resource182 4721 4722 init(_ r: @Resource182) { 4723 self.c = UInt64(1.0) 4724 self.r <- r 4725 } 4726 pub fun duplicate(): @Resource181{ 4727 return <- create Resource181(<-self.r.duplicate()) 4728 } 4729 4730 pub fun check(): Bool { 4731 let r <- create self.r.duplicate() 4732 let c = r.check() 4733 destroy r 4734 return c 4735 } 4736 4737 destroy(){ 4738 pre { 4739 self.check() 4740 } 4741 destroy self.r 4742 } 4743 } 4744 pub resource Resource182 { 4745 pub let c: UInt64 4746 pub let r: @Resource183 4747 4748 init(_ r: @Resource183) { 4749 self.c = UInt64(1.0) 4750 self.r <- r 4751 } 4752 pub fun duplicate(): @Resource182{ 4753 return <- create Resource182(<-self.r.duplicate()) 4754 } 4755 4756 pub fun check(): Bool { 4757 let r <- create self.r.duplicate() 4758 let c = r.check() 4759 destroy r 4760 return c 4761 } 4762 4763 destroy(){ 4764 pre { 4765 self.check() 4766 } 4767 destroy self.r 4768 } 4769 } 4770 pub resource Resource183 { 4771 pub let c: UInt64 4772 pub let r: @Resource184 4773 4774 init(_ r: @Resource184) { 4775 self.c = UInt64(1.0) 4776 self.r <- r 4777 } 4778 pub fun duplicate(): @Resource183{ 4779 return <- create Resource183(<-self.r.duplicate()) 4780 } 4781 4782 pub fun check(): Bool { 4783 let r <- create self.r.duplicate() 4784 let c = r.check() 4785 destroy r 4786 return c 4787 } 4788 4789 destroy(){ 4790 pre { 4791 self.check() 4792 } 4793 destroy self.r 4794 } 4795 } 4796 pub resource Resource184 { 4797 pub let c: UInt64 4798 pub let r: @Resource185 4799 4800 init(_ r: @Resource185) { 4801 self.c = UInt64(1.0) 4802 self.r <- r 4803 } 4804 pub fun duplicate(): @Resource184{ 4805 return <- create Resource184(<-self.r.duplicate()) 4806 } 4807 4808 pub fun check(): Bool { 4809 let r <- create self.r.duplicate() 4810 let c = r.check() 4811 destroy r 4812 return c 4813 } 4814 4815 destroy(){ 4816 pre { 4817 self.check() 4818 } 4819 destroy self.r 4820 } 4821 } 4822 pub resource Resource185 { 4823 pub let c: UInt64 4824 pub let r: @Resource186 4825 4826 init(_ r: @Resource186) { 4827 self.c = UInt64(1.0) 4828 self.r <- r 4829 } 4830 pub fun duplicate(): @Resource185{ 4831 return <- create Resource185(<-self.r.duplicate()) 4832 } 4833 4834 pub fun check(): Bool { 4835 let r <- create self.r.duplicate() 4836 let c = r.check() 4837 destroy r 4838 return c 4839 } 4840 4841 destroy(){ 4842 pre { 4843 self.check() 4844 } 4845 destroy self.r 4846 } 4847 } 4848 pub resource Resource186 { 4849 pub let c: UInt64 4850 pub let r: @Resource187 4851 4852 init(_ r: @Resource187) { 4853 self.c = UInt64(1.0) 4854 self.r <- r 4855 } 4856 pub fun duplicate(): @Resource186{ 4857 return <- create Resource186(<-self.r.duplicate()) 4858 } 4859 4860 pub fun check(): Bool { 4861 let r <- create self.r.duplicate() 4862 let c = r.check() 4863 destroy r 4864 return c 4865 } 4866 4867 destroy(){ 4868 pre { 4869 self.check() 4870 } 4871 destroy self.r 4872 } 4873 } 4874 pub resource Resource187 { 4875 pub let c: UInt64 4876 pub let r: @Resource188 4877 4878 init(_ r: @Resource188) { 4879 self.c = UInt64(1.0) 4880 self.r <- r 4881 } 4882 pub fun duplicate(): @Resource187{ 4883 return <- create Resource187(<-self.r.duplicate()) 4884 } 4885 4886 pub fun check(): Bool { 4887 let r <- create self.r.duplicate() 4888 let c = r.check() 4889 destroy r 4890 return c 4891 } 4892 4893 destroy(){ 4894 pre { 4895 self.check() 4896 } 4897 destroy self.r 4898 } 4899 } 4900 pub resource Resource188 { 4901 pub let c: UInt64 4902 pub let r: @Resource189 4903 4904 init(_ r: @Resource189) { 4905 self.c = UInt64(1.0) 4906 self.r <- r 4907 } 4908 pub fun duplicate(): @Resource188{ 4909 return <- create Resource188(<-self.r.duplicate()) 4910 } 4911 4912 pub fun check(): Bool { 4913 let r <- create self.r.duplicate() 4914 let c = r.check() 4915 destroy r 4916 return c 4917 } 4918 4919 destroy(){ 4920 pre { 4921 self.check() 4922 } 4923 destroy self.r 4924 } 4925 } 4926 pub resource Resource189 { 4927 pub let c: UInt64 4928 pub let r: @Resource190 4929 4930 init(_ r: @Resource190) { 4931 self.c = UInt64(1.0) 4932 self.r <- r 4933 } 4934 pub fun duplicate(): @Resource189{ 4935 return <- create Resource189(<-self.r.duplicate()) 4936 } 4937 4938 pub fun check(): Bool { 4939 let r <- create self.r.duplicate() 4940 let c = r.check() 4941 destroy r 4942 return c 4943 } 4944 4945 destroy(){ 4946 pre { 4947 self.check() 4948 } 4949 destroy self.r 4950 } 4951 } 4952 pub resource Resource190 { 4953 pub let c: UInt64 4954 pub let r: @Resource191 4955 4956 init(_ r: @Resource191) { 4957 self.c = UInt64(1.0) 4958 self.r <- r 4959 } 4960 pub fun duplicate(): @Resource190{ 4961 return <- create Resource190(<-self.r.duplicate()) 4962 } 4963 4964 pub fun check(): Bool { 4965 let r <- create self.r.duplicate() 4966 let c = r.check() 4967 destroy r 4968 return c 4969 } 4970 4971 destroy(){ 4972 pre { 4973 self.check() 4974 } 4975 destroy self.r 4976 } 4977 } 4978 pub resource Resource191 { 4979 pub let c: UInt64 4980 pub let r: @Resource192 4981 4982 init(_ r: @Resource192) { 4983 self.c = UInt64(1.0) 4984 self.r <- r 4985 } 4986 pub fun duplicate(): @Resource191{ 4987 return <- create Resource191(<-self.r.duplicate()) 4988 } 4989 4990 pub fun check(): Bool { 4991 let r <- create self.r.duplicate() 4992 let c = r.check() 4993 destroy r 4994 return c 4995 } 4996 4997 destroy(){ 4998 pre { 4999 self.check() 5000 } 5001 destroy self.r 5002 } 5003 } 5004 pub resource Resource192 { 5005 pub let c: UInt64 5006 pub let r: @Resource193 5007 5008 init(_ r: @Resource193) { 5009 self.c = UInt64(1.0) 5010 self.r <- r 5011 } 5012 pub fun duplicate(): @Resource192{ 5013 return <- create Resource192(<-self.r.duplicate()) 5014 } 5015 5016 pub fun check(): Bool { 5017 let r <- create self.r.duplicate() 5018 let c = r.check() 5019 destroy r 5020 return c 5021 } 5022 5023 destroy(){ 5024 pre { 5025 self.check() 5026 } 5027 destroy self.r 5028 } 5029 } 5030 pub resource Resource193 { 5031 pub let c: UInt64 5032 pub let r: @Resource194 5033 5034 init(_ r: @Resource194) { 5035 self.c = UInt64(1.0) 5036 self.r <- r 5037 } 5038 pub fun duplicate(): @Resource193{ 5039 return <- create Resource193(<-self.r.duplicate()) 5040 } 5041 5042 pub fun check(): Bool { 5043 let r <- create self.r.duplicate() 5044 let c = r.check() 5045 destroy r 5046 return c 5047 } 5048 5049 destroy(){ 5050 pre { 5051 self.check() 5052 } 5053 destroy self.r 5054 } 5055 } 5056 pub resource Resource194 { 5057 pub let c: UInt64 5058 pub let r: @Resource195 5059 5060 init(_ r: @Resource195) { 5061 self.c = UInt64(1.0) 5062 self.r <- r 5063 } 5064 pub fun duplicate(): @Resource194{ 5065 return <- create Resource194(<-self.r.duplicate()) 5066 } 5067 5068 pub fun check(): Bool { 5069 let r <- create self.r.duplicate() 5070 let c = r.check() 5071 destroy r 5072 return c 5073 } 5074 5075 destroy(){ 5076 pre { 5077 self.check() 5078 } 5079 destroy self.r 5080 } 5081 } 5082 pub resource Resource195 { 5083 pub let c: UInt64 5084 pub let r: @Resource196 5085 5086 init(_ r: @Resource196) { 5087 self.c = UInt64(1.0) 5088 self.r <- r 5089 } 5090 pub fun duplicate(): @Resource195{ 5091 return <- create Resource195(<-self.r.duplicate()) 5092 } 5093 5094 pub fun check(): Bool { 5095 let r <- create self.r.duplicate() 5096 let c = r.check() 5097 destroy r 5098 return c 5099 } 5100 5101 destroy(){ 5102 pre { 5103 self.check() 5104 } 5105 destroy self.r 5106 } 5107 } 5108 pub resource Resource196 { 5109 pub let c: UInt64 5110 pub let r: @Resource197 5111 5112 init(_ r: @Resource197) { 5113 self.c = UInt64(1.0) 5114 self.r <- r 5115 } 5116 pub fun duplicate(): @Resource196{ 5117 return <- create Resource196(<-self.r.duplicate()) 5118 } 5119 5120 pub fun check(): Bool { 5121 let r <- create self.r.duplicate() 5122 let c = r.check() 5123 destroy r 5124 return c 5125 } 5126 5127 destroy(){ 5128 pre { 5129 self.check() 5130 } 5131 destroy self.r 5132 } 5133 } 5134 pub resource Resource197 { 5135 pub let c: UInt64 5136 pub let r: @Resource198 5137 5138 init(_ r: @Resource198) { 5139 self.c = UInt64(1.0) 5140 self.r <- r 5141 } 5142 pub fun duplicate(): @Resource197{ 5143 return <- create Resource197(<-self.r.duplicate()) 5144 } 5145 5146 pub fun check(): Bool { 5147 let r <- create self.r.duplicate() 5148 let c = r.check() 5149 destroy r 5150 return c 5151 } 5152 5153 destroy(){ 5154 pre { 5155 self.check() 5156 } 5157 destroy self.r 5158 } 5159 } 5160 pub resource Resource198 { 5161 pub let c: UInt64 5162 pub let r: @Resource199 5163 5164 init(_ r: @Resource199) { 5165 self.c = UInt64(1.0) 5166 self.r <- r 5167 } 5168 pub fun duplicate(): @Resource198{ 5169 return <- create Resource198(<-self.r.duplicate()) 5170 } 5171 5172 pub fun check(): Bool { 5173 let r <- create self.r.duplicate() 5174 let c = r.check() 5175 destroy r 5176 return c 5177 } 5178 5179 destroy(){ 5180 pre { 5181 self.check() 5182 } 5183 destroy self.r 5184 } 5185 } 5186 pub resource Resource199 { 5187 pub let c: UInt64 5188 pub let r: @Resource200 5189 5190 init(_ r: @Resource200) { 5191 self.c = UInt64(1.0) 5192 self.r <- r 5193 } 5194 pub fun duplicate(): @Resource199{ 5195 return <- create Resource199(<-self.r.duplicate()) 5196 } 5197 5198 pub fun check(): Bool { 5199 let r <- create self.r.duplicate() 5200 let c = r.check() 5201 destroy r 5202 return c 5203 } 5204 5205 destroy(){ 5206 pre { 5207 self.check() 5208 } 5209 destroy self.r 5210 } 5211 } 5212 pub resource Resource200 { 5213 pub let c: UInt64 5214 5215 init() { 5216 self.c = UInt64(1.0) 5217 } 5218 pub fun duplicate(): @Resource200{ 5219 return <- create Resource200() 5220 } 5221 5222 pub fun check(): Bool { 5223 return true 5224 } 5225 5226 destroy(){ 5227 pre { 5228 self.check() 5229 } 5230 } 5231 }} 5232 5233 `