{ parameter (or

              (or

                (or

                  (pair %balance_of

                    (list %requests (pair (address %owner) (nat %token_id)))

                    (contract %callback (list (pair

                                              (pair %request (address %owner)

                                                             (nat %token_id))

                                              (nat %balance)))))

                  (or

                    (list %burn (pair (address %from_)

                                     (pair (nat %token_id) (nat %amount))))

                    (unit %claim_prize)))

                (or (nat %complete)

                    (or

                      (list %mint (pair (address %to_)

                                       (pair

                                         (or %token (nat %existing)

                                                    (map %new string bytes))

                                         (nat %amount))))

                      (nat %minter))))

              (or

                (or (address %set_administrator)

                    (or (big_map %set_metadata string bytes) (bool %set_pause)))

                (or

                  (list %transfer (pair (address %from_)

                                       (list %txs (pair (address %to_)

                                                       (pair (nat %token_id)

                                                             (nat %amount))))))

                  (or

                    (list %update_operators (or

                                             (pair %add_operator (address %owner)

                                                                 (pair

                                                                   (address %operator)

                                                                   (nat %token_id)))

                                             (pair %remove_operator (address %owner)

                                                                    (pair

                                                                      (address %operator)

                                                                      (nat %token_id)))))

                    (pair %withdraw_mutez (mutez %amount) (address %destination)))))) ;

  storage (pair

            (pair

              (pair

                (pair (address %administrator)

                      (map %claimable nat

                                      (pair (mutez %cost)

                                            (pair (map %requirements nat nat)

                                                  (nat %reward)))))

                (pair (nat %last_token_id) (nat %lastv)))

              (pair

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

                      (big_map %metadata string bytes))

                (pair (map %mint_allow_tokens nat nat) (map %mint_cost nat mutez))))

            (pair

              (pair

                (pair (map %mint_reduced_cost nat mutez)

                      (map %mint_reduced_cost_tokens nat nat))

                (pair (map %mintable nat (map nat nat))

                      (big_map %operators

                        (pair (address %owner)

                              (pair (address %operator) (nat %token_id)))

                        unit)))

              (pair (pair (bool %paused) (mutez %prize))

                    (pair (bool %prize_given)

                          (pair (big_map %supply nat nat)

                                (big_map %token_metadata nat

                                                         (pair (nat %token_id)

                                                               (map %token_info string

                                                                                bytes)))))))) ;

  code { UNPAIR ;

         IF_LEFT

           { IF_LEFT

               { IF_LEFT

                   { NIL operation ;

                     DUP ;

                     DUP 3 ;

                     CDR ;

                     PUSH mutez 0 ;

                     DUP 5 ;

                     CAR ;

                     MAP { DUP 7 ;

                           GET 10 ;

                           SWAP ;

                           DUP ;

                           DUG 2 ;

                           CDR ;

                           MEM ;

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

                           DUP 7 ;

                           CAR ;

                           GET 3 ;

                           CAR ;

                           SWAP ;

                           DUP ;

                           CDR ;

                           SWAP ;

                           DUP ;

                           DUG 3 ;

                           CAR ;

                           PAIR ;

                           GET ;

                           IF_NONE { PUSH nat 0 } {} ;

                           SWAP ;

                           PAIR } ;

                     DIG 4 ;

                     DROP ;

                     DIG 4 ;

                     DROP ;

                     TRANSFER_TOKENS ;

                     CONS }

                   { IF_LEFT

                       { DUP ;

                         ITER { DUP 3 ;

                                GET 10 ;

                                SWAP ;

                                DUP ;

                                DUG 2 ;

                                GET 3 ;

                                MEM ;

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

                                DUP ;

                                CAR ;

                                SENDER ;

                                COMPARE ;

                                EQ ;

                                IF

                                  { PUSH bool True }

                                  { DUP 3 ;

                                    GET 3 ;

                                    GET 4 ;

                                    SWAP ;

                                    DUP ;

                                    DUG 2 ;

                                    GET 3 ;

                                    SENDER ;

                                    DUP 4 ;

                                    CAR ;

                                    PAIR 3 ;

                                    MEM } ;

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

                                DUP 3 ;

                                UNPAIR ;

                                UNPAIR ;

                                SWAP ;

                                UNPAIR ;

                                UNPAIR ;

                                DUP 6 ;

                                GET 4 ;

                                DIG 8 ;

                                CAR ;

                                GET 3 ;

                                CAR ;

                                DIG 7 ;

                                DUP ;

                                GET 3 ;

                                SWAP ;

                                DUP ;

                                DUG 9 ;

                                CAR ;

                                PAIR ;

                                GET ;

                                IF_NONE { PUSH nat 0 } {} ;

                                SUB ;

                                ISNAT ;

                                IF_NONE

                                  { PUSH string "FA2_INSUFFICIENT_BALANCE" ; FAILWITH }

                                  {} ;

                                SOME ;

                                DIG 6 ;

                                DUP ;

                                GET 3 ;

                                SWAP ;

                                DUP ;

                                DUG 8 ;

                                CAR ;

                                PAIR ;

                                UPDATE ;

                                PAIR ;

                                PAIR ;

                                SWAP ;

                                PAIR ;

                                PAIR ;

                                DUG 2 ;

                                DUP ;

                                GET 4 ;

                                DUP 4 ;

                                GET 9 ;

                                DUP 3 ;

                                GET 3 ;

                                GET ;

                                IF_NONE { PUSH nat 0 } {} ;

                                SUB ;

                                ISNAT ;

                                IF_NONE

                                  { DIG 2 ;

                                    DUP ;

                                    GET 9 ;

                                    PUSH (option nat) (Some 0) ;

                                    DIG 3 ;

                                    GET 3 ;

                                    UPDATE ;

                                    UPDATE 9 ;

                                    SWAP }

                                  { DIG 3 ;

                                    DUP ;

                                    GET 9 ;

                                    DIG 2 ;

                                    SOME ;

                                    DIG 3 ;

                                    GET 3 ;

                                    UPDATE ;

                                    UPDATE 9 ;

                                    SWAP } } ;

                         DROP ;

                         NIL operation }

                       { SWAP ;

                         DUP ;

                         DUG 2 ;

                         GET 5 ;

                         CAR ;

                         IF

                           { PUSH (pair string string) (Pair "FA2_TX_DENIED" "FA2_PAUSED") ;

                             FAILWITH }

                           {} ;

                         SWAP ;

                         DUP ;

                         DUG 2 ;

                         GET 7 ;

                         IF { PUSH string "NOT AVAILABLE" ; FAILWITH } {} ;

                         PUSH nat 243 ;

                         PUSH bool True ;

                         PUSH nat 255 ;

                         DUP 3 ;

                         COMPARE ;

                         LT ;

                         IF { DUP } { PUSH bool False } ;

                         LOOP { DUP 4 ;

                                CAR ;

                                GET 3 ;

                                CAR ;

                                DUP 3 ;

                                SENDER ;

                                PAIR ;

                                MEM ;

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

                                PUSH nat 1 ;

                                DUP 5 ;

                                CAR ;

                                GET 3 ;

                                CAR ;

                                DUP 4 ;

                                SENDER ;

                                PAIR ;

                                GET ;

                                IF_NONE { PUSH int 188 ; FAILWITH } {} ;

                                COMPARE ;

                                GE ;

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

                                PUSH nat 1 ;

                                DIG 2 ;

                                ADD ;

                                SWAP ;

                                PUSH nat 255 ;

                                DUP 3 ;

                                COMPARE ;

                                LT ;

                                IF { DUP } { PUSH bool False } } ;

                         DROP 3 ;

                         NIL operation ;

                         SENDER ;

                         CONTRACT unit ;

                         IF_NONE { PUSH int 192 ; FAILWITH } {} ;

                         DUP 3 ;

                         GET 5 ;

                         CDR ;

                         UNIT ;

                         TRANSFER_TOKENS ;

                         CONS ;

                         SWAP ;

                         PUSH bool True ;

                         UPDATE 7 ;

                         UNPAIR ;

                         SWAP ;

                         UNPAIR ;

                         SWAP ;

                         UNPAIR ;

                         CAR ;

                         PUSH mutez 0 ;

                         SWAP ;

                         PAIR ;

                         PAIR ;

                         SWAP ;

                         PAIR ;

                         SWAP ;

                         PAIR ;

                         SWAP } } }

               { IF_LEFT

                   { SWAP ;

                     DUP ;

                     DUG 2 ;

                     GET 5 ;

                     CAR ;

                     IF

                       { PUSH (pair string string) (Pair "FA2_TX_DENIED" "FA2_PAUSED") ;

                         FAILWITH }

                       {} ;

                     SWAP ;

                     DUP ;

                     DUG 2 ;

                     CAR ;

                     CAR ;

                     CAR ;

                     CDR ;

                     SWAP ;

                     DUP ;

                     DUG 2 ;

                     GET ;

                     IF_NONE { PUSH int 137 ; FAILWITH } {} ;

                     CAR ;

                     AMOUNT ;

                     COMPARE ;

                     GE ;

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

                     SWAP ;

                     DUP ;

                     DUG 2 ;

                     CAR ;

                     CAR ;

                     CAR ;

                     CDR ;

                     SWAP ;

                     DUP ;

                     DUG 2 ;

                     GET ;

                     IF_NONE { PUSH int 139 ; FAILWITH } {} ;

                     GET 4 ;

                     PUSH nat 243 ;

                     COMPARE ;

                     LE ;

                     IF

                       { PUSH nat 254 ;

                         DUP 3 ;

                         CAR ;

                         CAR ;

                         CAR ;

                         CDR ;

                         DUP 3 ;

                         GET ;

                         IF_NONE { PUSH int 139 ; FAILWITH } {} ;

                         GET 4 ;

                         COMPARE ;

                         LE }

                       { PUSH bool False } ;

                     IF

                       { PUSH nat 10 ;

                         DIG 2 ;

                         DUP ;

                         GET 9 ;

                         SWAP ;

                         DUP ;

                         DUG 4 ;

                         CAR ;

                         CAR ;

                         CAR ;

                         CDR ;

                         DUP 4 ;

                         GET ;

                         IF_NONE { PUSH int 140 ; FAILWITH } {} ;

                         GET 4 ;

                         GET ;

                         IF_NONE { PUSH int 140 ; FAILWITH } {} ;

                         COMPARE ;

                         LT ;

                         IF {} { PUSH string "NOT AVAILABLE" ; FAILWITH } }

                       {} ;

                     SWAP ;

                     DUP ;

                     DUG 2 ;

                     CAR ;

                     CAR ;

                     CAR ;

                     CDR ;

                     SWAP ;

                     DUP ;

                     DUG 2 ;

                     GET ;

                     IF_NONE { PUSH int 142 ; FAILWITH } {} ;

                     GET 3 ;

                     ITER { DUP 3 ;

                            GET 10 ;

                            SWAP ;

                            DUP ;

                            DUG 2 ;

                            CAR ;

                            MEM ;

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

                            DUP 3 ;

                            CAR ;

                            GET 3 ;

                            CAR ;

                            SWAP ;

                            DUP ;

                            DUG 2 ;

                            CAR ;

                            SENDER ;

                            PAIR ;

                            MEM ;

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

                            DUP ;

                            CDR ;

                            DUP 4 ;

                            CAR ;

                            GET 3 ;

                            CAR ;

                            DUP 3 ;

                            CAR ;

                            SENDER ;

                            PAIR ;

                            GET ;

                            IF_NONE { PUSH int 147 ; FAILWITH } {} ;

                            COMPARE ;

                            GE ;

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

                            DUP 3 ;

                            UNPAIR ;

                            UNPAIR ;

                            SWAP ;

                            UNPAIR ;

                            UNPAIR ;

                            DUP 6 ;

                            CDR ;

                            DIG 8 ;

                            CAR ;

                            GET 3 ;

                            CAR ;

                            DUP 8 ;

                            CAR ;

                            SENDER ;

                            PAIR ;

                            GET ;

                            IF_NONE { PUSH nat 0 } {} ;

                            SUB ;

                            ISNAT ;

                            IF_NONE

                              { PUSH string "FA2_INSUFFICIENT_BALANCE" ; FAILWITH }

                              {} ;

                            SOME ;

                            DUP 7 ;

                            CAR ;

                            SENDER ;

                            PAIR ;

                            UPDATE ;

                            PAIR ;

                            PAIR ;

                            SWAP ;

                            PAIR ;

                            PAIR ;

                            DUG 2 ;

                            DUP ;

                            CDR ;

                            DUP 4 ;

                            GET 9 ;

                            DUP 3 ;

                            CAR ;

                            GET ;

                            IF_NONE { PUSH nat 0 } {} ;

                            SUB ;

                            ISNAT ;

                            IF_NONE

                              { DIG 2 ;

                                DUP ;

                                GET 9 ;

                                PUSH (option nat) (Some 0) ;

                                DIG 3 ;

                                CAR ;

                                UPDATE ;

                                UPDATE 9 ;

                                SWAP }

                              { DIG 3 ; DUP ; GET 9 ; DIG 2 ; SOME ; DIG 3 ; CAR ; UPDATE ; UPDATE 9 ; SWAP } } ;

                     SWAP ;

                     DUP ;

                     DUG 2 ;

                     GET 7 ;

                     IF

                       {}

                       { SWAP ;

                         DUP ;

                         DUG 2 ;

                         UNPAIR ;

                         SWAP ;

                         UNPAIR ;

                         SWAP ;

                         UNPAIR ;

                         UNPAIR ;

                         SWAP ;

                         PUSH mutez 1 ;

                         PUSH nat 10 ;

                         PUSH mutez 1 ;

                         DIG 9 ;

                         CAR ;

                         CAR ;

                         CAR ;

                         CDR ;

                         DUP 10 ;

                         GET ;

                         IF_NONE { PUSH int 165 ; FAILWITH } {} ;

                         CAR ;

                         EDIV ;

                         IF_NONE { UNIT ; FAILWITH } {} ;

                         CAR ;

                         EDIV ;

                         IF_NONE { PUSH int 165 ; FAILWITH } { CAR } ;

                         MUL ;

                         ADD ;

                         SWAP ;

                         PAIR ;

                         PAIR ;

                         SWAP ;

                         PAIR ;

                         SWAP ;

                         PAIR ;

                         SWAP } ;

                     SWAP ;

                     DUP ;

                     DUG 2 ;

                     DUP ;

                     GET 9 ;

                     DUP ;

                     DIG 4 ;

                     CAR ;

                     CAR ;

                     CAR ;

                     CDR ;

                     DUP 5 ;

                     GET ;

                     IF_NONE { PUSH int 167 ; FAILWITH } {} ;

                     GET 4 ;

                     DUP ;

                     DUG 2 ;

                     GET ;

                     IF_NONE { PUSH int 167 ; FAILWITH } {} ;

                     PUSH nat 1 ;

                     ADD ;

                     SOME ;

                     SWAP ;

                     UPDATE ;

                     UPDATE 9 ;

                     DUP ;

                     CAR ;

                     GET 3 ;

                     CAR ;

                     SWAP ;

                     DUP ;

                     DUG 3 ;

                     CAR ;

                     CAR ;

                     CAR ;

                     CDR ;

                     DUP 3 ;

                     GET ;

                     IF_NONE { PUSH int 170 ; FAILWITH } {} ;

                     GET 4 ;

                     SENDER ;

                     PAIR ;

                     MEM ;

                     IF

                       { SWAP ;

                         DUP ;

                         DUG 2 ;

                         UNPAIR ;

                         UNPAIR ;

                         SWAP ;

                         UNPAIR ;

                         UNPAIR ;

                         DUP ;

                         DIG 7 ;

                         CAR ;

                         CAR ;

                         CAR ;

                         CDR ;

                         DIG 7 ;

                         GET ;

                         IF_NONE { PUSH int 170 ; FAILWITH } {} ;

                         GET 4 ;

                         SENDER ;

                         PAIR ;

                         DUP ;

                         DUG 2 ;

                         GET ;

                         IF_NONE { PUSH int 172 ; FAILWITH } {} ;

                         PUSH nat 1 ;

                         ADD ;

                         SOME ;

                         SWAP ;

                         UPDATE ;

                         PAIR ;

                         PAIR ;

                         SWAP ;

                         PAIR ;

                         PAIR }

                       { SWAP ;

                         DUP ;

                         DUG 2 ;

                         UNPAIR ;

                         UNPAIR ;

                         SWAP ;

                         UNPAIR ;

                         UNPAIR ;

                         PUSH (option nat) (Some 1) ;

                         DIG 7 ;

                         CAR ;

                         CAR ;

                         CAR ;

                         CDR ;

                         DIG 7 ;

                         GET ;

                         IF_NONE { PUSH int 170 ; FAILWITH } {} ;

                         GET 4 ;

                         SENDER ;

                         PAIR ;

                         UPDATE ;

                         PAIR ;

                         PAIR ;

                         SWAP ;

                         PAIR ;

                         PAIR } }

                   { IF_LEFT

                       { SWAP ;

                         DUP ;

                         DUG 2 ;

                         CAR ;

                         CAR ;

                         CAR ;

                         CAR ;

                         SENDER ;

                         COMPARE ;

                         EQ ;

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

                         DUP ;

                         ITER { DUP ;

                                GET 3 ;

                                IF_LEFT

                                  { DUP 4 ;

                                    GET 10 ;

                                    SWAP ;

                                    DUP ;

                                    DUG 2 ;

                                    MEM ;

                                    IF

                                      {}

                                      { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH } ;

                                    DIG 3 ;

                                    DUP ;

                                    GET 9 ;

                                    DUP ;

                                    DUP 4 ;

                                    DUP ;

                                    DUG 2 ;

                                    GET ;

                                    IF_NONE { PUSH int 643 ; FAILWITH } {} ;

                                    DUP 6 ;

                                    GET 4 ;

                                    ADD ;

                                    SOME ;

                                    SWAP ;

                                    UPDATE ;

                                    UPDATE 9 ;

                                    DUP ;

                                    DUG 4 ;

                                    UNPAIR ;

                                    UNPAIR ;

                                    SWAP ;

                                    UNPAIR ;

                                    UNPAIR ;

                                    DUP 7 ;

                                    GET 4 ;

                                    DIG 9 ;

                                    CAR ;

                                    GET 3 ;

                                    CAR ;

                                    DUP 8 ;

                                    DUP 10 ;

                                    CAR ;

                                    PAIR ;

                                    GET ;

                                    IF_NONE { PUSH nat 0 } {} ;

                                    ADD ;

                                    SOME ;

                                    DIG 6 ;

                                    DIG 7 ;

                                    CAR ;

                                    PAIR ;

                                    UPDATE ;

                                    PAIR ;

                                    PAIR ;

                                    SWAP ;

                                    PAIR ;

                                    PAIR ;

                                    SWAP }

                                  { DUP 4 ;

                                    CAR ;

                                    CAR ;

                                    GET 3 ;

                                    DIG 4 ;

                                    DUP ;

                                    GET 10 ;

                                    DIG 3 ;

                                    DUP 4 ;

                                    PAIR ;

                                    SOME ;

                                    DUP 4 ;

                                    UPDATE ;

                                    UPDATE 10 ;

                                    DUP ;

                                    GET 9 ;

                                    DUP 4 ;

                                    GET 4 ;

                                    SOME ;

                                    DUP 4 ;

                                    UPDATE ;

                                    UPDATE 9 ;

                                    UNPAIR ;

                                    UNPAIR ;

                                    SWAP ;

                                    UNPAIR ;

                                    UNPAIR ;

                                    DUP 7 ;

                                    GET 4 ;

                                    SOME ;

                                    DIG 6 ;

                                    DIG 7 ;

                                    CAR ;

                                    PAIR ;

                                    UPDATE ;

                                    PAIR ;

                                    PAIR ;

                                    SWAP ;

                                    UNPAIR ;

                                    SWAP ;

                                    UNPAIR ;

                                    PUSH nat 1 ;

                                    ADD ;

                                    PAIR ;

                                    SWAP ;

                                    PAIR ;

                                    PAIR ;

                                    PAIR ;

                                    SWAP } } ;

                         DROP }

                       { SWAP ;

                         DUP ;

                         DUG 2 ;

                         GET 5 ;

                         CAR ;

                         IF

                           { PUSH (pair string string) (Pair "FA2_TX_DENIED" "FA2_PAUSED") ;

                             FAILWITH }

                           {} ;

                         DUP ;

                         PUSH nat 4 ;

                         COMPARE ;

                         GT ;

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

                         SWAP ;

                         DUP ;

                         DUG 2 ;

                         CAR ;

                         GET 5 ;

                         SWAP ;

                         DUP ;

                         DUG 2 ;

                         MEM ;

                         IF

                           { SWAP ;

                             DUP ;

                             CAR ;

                             GET 3 ;

                             CAR ;

                             SWAP ;

                             DUP ;

                             DUG 3 ;

                             CAR ;

                             GET 5 ;

                             DUP 3 ;

                             GET ;

                             IF_NONE { PUSH int 87 ; FAILWITH } {} ;

                             SENDER ;

                             PAIR ;

                             MEM ;

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

                             PUSH nat 0 ;

                             DIG 2 ;

                             DUP ;

                             CAR ;

                             GET 3 ;

                             CAR ;

                             SWAP ;

                             DUP ;

                             DUG 4 ;

                             CAR ;

                             GET 5 ;

                             DUP 4 ;

                             GET ;

                             IF_NONE { PUSH int 87 ; FAILWITH } {} ;

                             SENDER ;

                             PAIR ;

                             GET ;

                             IF_NONE { PUSH int 89 ; FAILWITH } {} ;

                             COMPARE ;

                             GT ;

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

                           {} ;

                         SWAP ;

                         DUP ;

                         DUG 2 ;

                         CAR ;

                         GET 6 ;

                         SWAP ;

                         DUP ;

                         DUG 2 ;

                         GET ;

                         IF_NONE { PUSH int 93 ; FAILWITH } {} ;

                         DUP 3 ;

                         GET 3 ;

                         CAR ;

                         CDR ;

                         DUP 3 ;

                         MEM ;

                         IF

                           { DIG 2 ;