parameter (or

            (or

              (or %adminAction (or (map %accumulate address nat) (bool %pauseSale))

                               (or (pair %reveal bytes nat) (map %uploadDna nat bytes)))

              (pair %fuse (pair %tokensIds nat nat) (bytes %dna)))

            (list %verifyBalance (pair (pair %request (address %owner) (nat %token_id))

                                      (nat %balance))));

storage (pair (big_map %metadata string bytes)

              (pair %sale (bool %paused) (address %inTokenAddress)

                          (address %outTokenAddress)

                          (mutez %price)

                          (mutez %recharge)

                          (nat %fuseTokens)

                          (int %rechargeInterval)

                          (nat %soldAmount)

                          (nat %saleSupply)

                          (bytes %placeholderIpfs)

                          (nat %nextId))

              (big_map %tokenDna nat bytes)

              (big_map %tokenDnaRev bytes nat)

              (big_map %mintedDna bytes nat)

              (big_map %ledger address (pair (nat %accumulated) (nat %used)))

              (big_map %cooldown nat timestamp)

              (map %recipients address nat)

              (address %admin));

code { NIL operation ;

       LAMBDA

         (pair nat (big_map string bytes)

               (pair bool address address mutez mutez nat int nat nat bytes nat)

               (big_map nat bytes)

               (big_map bytes nat)

               (big_map bytes nat)

               (big_map address (pair nat nat))

               (big_map nat timestamp)

               (map address nat)

               address)

         timestamp

         { UNPAIR ; SWAP ; GET 13 ; SWAP ; GET ; IF_NONE { PUSH int 1 ; NOW ; SUB } {} } ;

       LAMBDA

         (pair address (big_map string bytes)

               (pair bool address address mutez mutez nat int nat nat bytes nat)

               (big_map nat bytes)

               (big_map bytes nat)

               (big_map bytes nat)

               (big_map address (pair nat nat))

               (big_map nat timestamp)

               (map address nat)

               address)

         (pair nat nat)

         { UNPAIR ; SWAP ; GET 11 ; SWAP ; GET ; IF_NONE { PUSH nat 0 ; PUSH nat 0 ; PAIR } {} } ;

       DIG 3 ;

       UNPAIR ;

       IF_LEFT

         { IF_LEFT

             { DIG 3 ;

               DROP ;

               PUSH bool False ;

               DUP 3 ;

               GET 16 ;

               SENDER ;

               COMPARE ;

               EQ ;

               COMPARE ;

               EQ ;

               IF { PUSH string "INVALID_ACCESS" ; FAILWITH } {} ;

               IF_LEFT

                 { IF_LEFT

                     { ITER { UNPAIR ;

                              DUP 3 ;

                              DUP 2 ;

                              PAIR ;

                              DUP 5 ;

                              SWAP ;

                              EXEC ;

                              DIG 2 ;

                              UPDATE 1 ;

                              DUP 3 ;

                              DIG 3 ;

                              GET 11 ;

                              DIG 2 ;

                              DIG 3 ;

                              SWAP ;

                              SOME ;

                              SWAP ;

                              UPDATE ;

                              UPDATE 11 } ;

                       SWAP ;

                       DROP }

                     { DIG 2 ; DROP ; SWAP ; DUP ; GET 3 ; DIG 2 ; UPDATE 1 ; UPDATE 3 } ;

                   SWAP }

                 { DIG 2 ;

                   DROP ;

                   IF_LEFT

                     { DIG 2 ;

                       DROP ;

                       DUP 2 ;

                       GET 3 ;

                       GET 5 ;

                       CONTRACT %reveal (pair (pair bytes nat) nat) ;

                       IF_NONE

                         { PUSH string "CANNOT_INVOKE_FA2_REVEAL" ; FAILWITH }

                         {} ;

                       DIG 2 ;

                       NIL operation ;

                       DIG 2 ;

                       PUSH mutez 0 ;

                       DUP 5 ;

                       CDR ;

                       DIG 5 ;

                       PAIR ;

                       TRANSFER_TOKENS ;

                       CONS }

                     { ITER { UNPAIR ;

                              DUP 3 ;

                              DIG 3 ;

                              GET 5 ;

                              DUP 4 ;

                              DUP 4 ;

                              SWAP ;

                              SOME ;

                              SWAP ;

                              UPDATE ;

                              UPDATE 5 ;

                              DUG 2 ;

                              DUP 3 ;

                              DIG 3 ;

                              GET 7 ;

                              DIG 2 ;

                              DIG 3 ;

                              SWAP ;

                              SOME ;

                              SWAP ;

                              UPDATE ;

                              UPDATE 7 } ;

                       SWAP } } }

             { DIG 4 ;

               DROP ;

               SWAP ;

               PUSH bool True ;

               DUP 2 ;

               GET 3 ;

               CAR ;

               COMPARE ;

               EQ ;

               IF { PUSH string "SALE_PAUSED" ; FAILWITH } {} ;

               DUP ;

               GET 3 ;

               GET 17 ;

               DUP 2 ;

               GET 3 ;

               GET 15 ;

               COMPARE ;

               GE ;

               IF { PUSH string "SOLD_OUT" ; FAILWITH } {} ;

               DUP ;

               GET 3 ;

               GET 7 ;

               NOW ;

               DUP 3 ;

               DUP 5 ;

               CAR ;

               CAR ;

               PAIR ;

               DUP 7 ;

               SWAP ;

               EXEC ;

               COMPARE ;

               GT ;

               IF { DUP 2 ; GET 3 ; GET 9 ; ADD } {} ;

               NOW ;

               DUP 3 ;

               DUP 5 ;

               CAR ;

               CDR ;

               PAIR ;

               DIG 6 ;

               SWAP ;

               EXEC ;

               COMPARE ;

               GT ;

               IF { DUP 2 ; GET 3 ; GET 9 ; ADD } {} ;

               AMOUNT ;

               COMPARE ;

               NEQ ;

               IF { PUSH string "INVALID_AMOUNT" ; FAILWITH } {} ;

               DUP ;

               SENDER ;

               PAIR ;

               DIG 3 ;

               SWAP ;

               EXEC ;

               DUP ;

               CDR ;

               DUP 2 ;

               CAR ;

               SUB ;

               ISNAT ;

               IF_NONE { PUSH string "option is None" ; FAILWITH } {} ;

               DUP 3 ;

               GET 3 ;

               GET 11 ;

               SWAP ;

               COMPARE ;

               LT ;

               IF { PUSH string "INVALID_FUSE_BALANCE" ; FAILWITH } {} ;

               DUP 2 ;

               DUP 4 ;

               PUSH nat 9 ;

               DUP 2 ;

               CDR ;

               SIZE ;

               COMPARE ;

               NEQ ;

               IF { PUSH string "INVALID_DNA" ; FAILWITH } {} ;

               PUSH bool True ;

               DUP 3 ;

               GET 7 ;

               DUP 3 ;

               CDR ;

               MEM ;

               COMPARE ;

               EQ ;

               IF { PUSH string "DUPLICATE_DNA_GEN1" ; FAILWITH } {} ;

               PUSH bool True ;

               DUP 3 ;

               GET 9 ;

               DUP 3 ;

               CDR ;

               MEM ;

               COMPARE ;

               EQ ;

               IF { PUSH string "DUPLICATE_DNA_GEN2" ; FAILWITH } {} ;

               DUP 2 ;

               GET 5 ;

               DUP 2 ;

               CAR ;

               CAR ;

               GET ;

               IF_NONE { PUSH string "INVALID_TOKEN_ID" ; FAILWITH } {} ;

               DIG 2 ;

               GET 5 ;

               DUP 3 ;

               CAR ;

               CDR ;

               GET ;

               IF_NONE { PUSH string "INVALID_TOKEN_ID" ; FAILWITH } {} ;

               PUSH int 1 ;

               PUSH int 8 ;

               PUSH int 0 ;

               DUP 2 ;

               DUP 2 ;

               COMPARE ;

               LE ;

               LOOP { DUP ;

                      DUG 3 ;

                      DIP 3

                           { DUP 4 ;

                             CDR ;

                             PUSH nat 1 ;

                             DUP 3 ;

                             ABS ;

                             SLICE ;

                             IF_NONE { PUSH string "SLICE" ; FAILWITH } {} ;

                             DUP 3 ;

                             PUSH nat 1 ;

                             DUP 4 ;

                             ABS ;

                             SLICE ;

                             IF_NONE { PUSH string "SLICE" ; FAILWITH } {} ;

                             DUP 2 ;

                             COMPARE ;

                             NEQ ;

                             DUP 5 ;

                             PUSH nat 1 ;

                             DIG 4 ;

                             ABS ;

                             SLICE ;

                             IF_NONE { PUSH string "SLICE" ; FAILWITH } {} ;

                             DIG 2 ;

                             COMPARE ;

                             NEQ ;

                             AND ;

                             IF { PUSH string "INVALID_DNA" ; FAILWITH } {} } ;

                      DUP 3 ;

                      ADD ;

                      DUP 2 ;

                      DUP 2 ;

                      COMPARE ;

                      LE } ;

               DROP 3 ;

               DROP 3 ;

               NIL operation ;

               EMPTY_MAP string bytes ;

               PUSH string ".json" ;

               DUP 5 ;

               GET 3 ;

               GET 20 ;

               { PUSH string "" ;

                 PAIR ;

                 LEFT (pair string nat) ;

                 LOOP_LEFT { DUP ;

                             CDR ;

                             PUSH nat 0 ;

                             SWAP ;

                             DUP ;

                             DUG 2 ;

                             COMPARE ;

                             GT ;

                             IF

                               { SWAP ;

                                 CAR ;

                                 PUSH nat 10 ;

                                 DUP 3 ;

                                 EDIV ;

                                 IF_NONE { PUSH string "MOD by 0" ; FAILWITH } {} ;

                                 CDR ;

                                 EMPTY_MAP nat string ;

                                 PUSH string "9" ;

                                 SOME ;

                                 PUSH nat 9 ;

                                 UPDATE ;

                                 PUSH string "8" ;

                                 SOME ;

                                 PUSH nat 8 ;

                                 UPDATE ;

                                 PUSH string "7" ;

                                 SOME ;

                                 PUSH nat 7 ;

                                 UPDATE ;

                                 PUSH string "6" ;

                                 SOME ;

                                 PUSH nat 6 ;

                                 UPDATE ;

                                 PUSH string "5" ;

                                 SOME ;

                                 PUSH nat 5 ;

                                 UPDATE ;

                                 PUSH string "4" ;

                                 SOME ;

                                 PUSH nat 4 ;

                                 UPDATE ;

                                 PUSH string "3" ;

                                 SOME ;

                                 PUSH nat 3 ;

                                 UPDATE ;

                                 PUSH string "2" ;

                                 SOME ;

                                 PUSH nat 2 ;

                                 UPDATE ;

                                 PUSH string "1" ;

                                 SOME ;

                                 PUSH nat 1 ;

                                 UPDATE ;

                                 PUSH string "0" ;

                                 SOME ;

                                 PUSH nat 0 ;

                                 UPDATE ;

                                 SWAP ;

                                 GET ;

                                 IF_NONE { PUSH string "INVALID_NAT" ; FAILWITH } {} ;

                                 CONCAT ;

                                 PUSH nat 10 ;

                                 DIG 2 ;

                                 EDIV ;

                                 IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ;

                                 CAR ;

                                 SWAP ;

                                 PAIR ;

                                 LEFT (pair string nat) }

                               { DROP ; RIGHT (pair string nat) } } ;

                 CAR ;

                 PUSH string "" ;

                 SWAP ;

                 DUP ;

                 DUG 2 ;

                 COMPARE ;

                 EQ ;

                 IF { DROP ; PUSH string "0" } {} } ;

               CONCAT ;

               PACK ;

               DUP ;

               PUSH nat 6 ;

               DIG 2 ;

               SIZE ;

               SUB ;

               ABS ;

               PUSH nat 6 ;

               SLICE ;

               IF_NONE { PUSH string "SLICE" ; FAILWITH } {} ;

               DUP 5 ;

               GET 3 ;

               GET 19 ;

               CONCAT ;

               SOME ;

               PUSH string "" ;

               UPDATE ;

               DUP 4 ;

               GET 3 ;

               GET 20 ;

               PUSH nat 1 ;

               SENDER ;

               PAIR 4 ;

               DUP 4 ;

               GET 3 ;

               GET 5 ;

               CONTRACT %mint (pair (address %address) (nat %amount) (nat %token_id)

                                    (map %metadata string bytes)) ;

               IF_NONE { PUSH string "CANNOT_INVOKE_FA2_MINT" ; FAILWITH } {} ;

               PUSH mutez 0 ;

               DIG 2 ;

               TRANSFER_TOKENS ;

               CONS ;

               SELF %verifyBalance ;

               NIL (pair address nat) ;

               DUP 6 ;

               CAR ;

               CDR ;

               SENDER ;

               PAIR ;

               CONS ;

               DUP 6 ;

               CAR ;

               CAR ;

               SENDER ;

               PAIR ;

               CONS ;

               PAIR ;

               DUP 4 ;

               GET 3 ;

               GET 3 ;

               CONTRACT %balance_of (pair

                                      (list %requests (pair (address %owner)

                                                           (nat %token_id)))

                                      (contract %callback (list (pair

                                                                (pair %request

                                                                  (address %owner)

                                                                  (nat %token_id))

                                                                (nat %balance))))) ;

               IF_NONE { PUSH string "CANNOT_INVOKE_FA2_BALANCE_OF" ; FAILWITH } {} ;

               PUSH mutez 0 ;

               DIG 2 ;

               TRANSFER_TOKENS ;

               CONS ;

               DUP 3 ;

               GET 15 ;

               ITER { UNPAIR ;

                      PUSH nat 10000 ;

                      DIG 2 ;

                      AMOUNT ;

                      MUL ;

                      EDIV ;

                      IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ;

                      CAR ;

                      SWAP ;

                      CONTRACT unit ;

                      IF_NONE { PUSH string "INVALID_TEZ_DESTINATION" ; FAILWITH } {} ;

                      SWAP ;

                      UNIT ;

                      TRANSFER_TOKENS ;

                      CONS } ;

               DUP 3 ;

               DUP 4 ;

               GET 9 ;

               DIG 4 ;

               GET 3 ;

               GET 20 ;

               DUP 6 ;

               CDR ;

               SWAP ;

               SOME ;

               SWAP ;

               UPDATE ;

               UPDATE 9 ;

               DUG 2 ;

               DUP 3 ;

               DUP 4 ;

               GET 3 ;

               PUSH nat 1 ;

               DIG 5 ;

               GET 3 ;

               GET 20 ;

               ADD ;

               UPDATE 20 ;

               UPDATE 3 ;

               DUG 2 ;

               DUP 3 ;

               DUP 4 ;

               GET 3 ;

               PUSH nat 1 ;

               DIG 5 ;

               GET 3 ;

               GET 15 ;

               ADD ;

               UPDATE 15 ;

               UPDATE 3 ;

               DUG 2 ;

               DUP 2 ;

               DUP 4 ;

               GET 3 ;

               GET 11 ;

               DIG 3 ;

               CDR ;

               ADD ;

               UPDATE 2 ;

               SWAP ;

               DUP 3 ;

               DIG 3 ;

               GET 11 ;

               DIG 3 ;

               SENDER ;

               SWAP ;

               SOME ;

               SWAP ;

               UPDATE ;

               UPDATE 11 ;

               SWAP ;

               DUP 2 ;

               DUP 3 ;

               GET 13 ;

               DIG 3 ;

               GET 3 ;

               GET 13 ;

               NOW ;

               ADD ;

               DUP 5 ;

               CAR ;

               CAR ;

               SWAP ;

               SOME ;

               SWAP ;

               UPDATE ;

               UPDATE 13 ;

               SWAP ;

               DUP 2 ;

               DUP 3 ;

               GET 13 ;

               DIG 3 ;

               GET 3 ;

               GET 13 ;

               NOW ;

               ADD ;

               DIG 4 ;

               CAR ;

               CDR ;

               SWAP ;

               SOME ;

               SWAP ;

               UPDATE ;

               UPDATE 13 ;

               SWAP } }

         { DIG 2 ;

           DIG 3 ;

           DROP 2 ;

           ITER { PUSH nat 1 ;

                  SWAP ;

                  CDR ;

                  COMPARE ;

                  LT ;

                  IF { PUSH string "FA2_INSUFFICIENT_BALANCE" ; FAILWITH } {} } ;

           SWAP } ;

       PAIR }