parameter (or

            (or

              (or (pair %approve (address %spender) (nat %value))

                  (or (unit %disableMinting)

                      (pair %getAdministrator unit (contract (option address)))))

              (or

                (pair %getAllowance (pair (address %owner) (address %spender))

                                    (contract nat))

                (or (pair %getBalance address (contract nat))

                    (pair %getPriorBalance (pair (address %address) (nat %level))

                                           (contract (pair (address %address)

                                                          (pair (nat %level)

                                                                (nat %result))))))))

            (or

              (or (pair %getTotalSupply unit (contract nat))

                  (or (pair %mint (address %address) (nat %value))

                      (option %setAdministrator address)))

              (or

                (or (bool %setPause)

                    (pair %transfer (address %from) (pair (address %to) (nat %value))))

                (or (pair %updateContractMetadata string bytes)

                    (pair %updateTokenMetadata (nat %token_id)

                                               (map %token_info string bytes))))));

storage (pair

          (pair

            (pair (option %administrator address)

                  (big_map %approvals address (map address nat)))

            (pair (big_map %balances address nat)

                  (pair

                    (big_map %checkpoints (pair address nat)

                                          (pair (nat %fromBlock) (nat %balance)))

                    (big_map %metadata string bytes))))

          (pair (pair (bool %mintingDisabled) (big_map %numCheckpoints address nat))

                (pair (bool %paused)

                      (pair

                        (big_map %token_metadata nat

                                                 (pair (nat %token_id)

                                                       (map %token_info string bytes)))

                        (nat %totalSupply)))));

code { LAMBDA

         (pair

           (pair %in_param (address %checkpointedAddress)

                           (pair (nat %numCheckpoints) (nat %newBalance)))

           (pair %in_storage

             (pair

               (pair (option %administrator address)

                     (big_map %approvals address (map address nat)))

               (pair (big_map %balances address nat)

                     (pair

                       (big_map %checkpoints (pair address nat)

                                             (pair (nat %fromBlock) (nat %balance)))

                       (big_map %metadata string bytes))))

             (pair (pair (bool %mintingDisabled) (big_map %numCheckpoints address nat))

                   (pair (bool %paused)

                         (pair

                           (big_map %token_metadata nat

                                                    (pair (nat %token_id)

                                                          (map %token_info string bytes)))

                           (nat %totalSupply))))))

         (pair (list %operations operation)

               (pair (unit %result)

                     (pair %storage

                       (pair

                         (pair (option %administrator address)

                               (big_map %approvals address (map address nat)))

                         (pair (big_map %balances address nat)

                               (pair

                                 (big_map %checkpoints (pair address nat)

                                                       (pair (nat %fromBlock)

                                                             (nat %balance)))

                                 (big_map %metadata string bytes))))

                       (pair

                         (pair (bool %mintingDisabled)

                               (big_map %numCheckpoints address nat))

                         (pair (bool %paused)

                               (pair

                                 (big_map %token_metadata nat

                                                          (pair (nat %token_id)

                                                                (map %token_info string

                                                                                 bytes)))

                                 (nat %totalSupply)))))))

         { NIL operation ;

           SWAP ;

           DUP ;

           DUG 2 ;

           CDR ;

           PUSH nat 0 ;

           DUP 4 ;

           CAR ;

           CDR ;

           CAR ;

           COMPARE ;

           EQ ;

           IF

             { UNPAIR ;

               UNPAIR ;

               SWAP ;

               UNPAIR ;

               SWAP ;

               UNPAIR ;

               DUP 7 ;

               CAR ;

               CDR ;

               CDR ;

               LEVEL ;

               PAIR %fromBlock %balance ;

               SOME ;

               PUSH nat 0 ;

               DUP 9 ;

               CAR ;

               CAR ;

               PAIR ;

               UPDATE ;

               PAIR ;

               SWAP ;

               PAIR ;

               SWAP ;

               PAIR ;

               SWAP ;

               UNPAIR ;

               UNPAIR ;

               SWAP ;

               PUSH nat 1 ;

               DUP 7 ;

               CAR ;

               CDR ;

               CAR ;

               ADD ;

               SOME ;

               DIG 6 ;

               CAR ;

               CAR ;

               UPDATE ;

               SWAP ;

               PAIR ;

               PAIR ;

               SWAP ;

               PAIR }

             { DUP ;

               CAR ;

               CDR ;

               CDR ;

               CAR ;

               LEVEL ;

               SWAP ;

               PUSH nat 1 ;

               DUP 6 ;

               CAR ;

               CDR ;

               CAR ;

               SUB ;

               ISNAT ;

               { IF_NONE { PUSH int 118 ; FAILWITH } {} } ;

               DUP 6 ;

               CAR ;

               CAR ;

               PAIR ;

               GET ;

               { IF_NONE { PUSH int 118 ; FAILWITH } {} } ;

               CAR ;

               COMPARE ;

               EQ ;

               IF

                 { UNPAIR ;

                   UNPAIR ;

                   SWAP ;

                   UNPAIR ;

                   SWAP ;

                   UNPAIR ;

                   DUP 7 ;

                   CAR ;

                   CDR ;

                   CDR ;

                   LEVEL ;

                   PAIR %fromBlock %balance ;

                   SOME ;

                   PUSH nat 1 ;

                   DUP 9 ;

                   CAR ;

                   CDR ;

                   CAR ;

                   SUB ;

                   ISNAT ;

                   { IF_NONE { PUSH int 119 ; FAILWITH } {} } ;

                   DIG 8 ;

                   CAR ;

                   CAR ;

                   PAIR ;

                   UPDATE ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   PAIR }

                 { DUP 3 ;

                   CAR ;

                   CDR ;

                   CDR ;

                   SWAP ;

                   DUP ;

                   DUG 2 ;

                   CAR ;

                   CDR ;

                   CDR ;

                   CAR ;

                   PUSH nat 1 ;

                   DUP 6 ;

                   CAR ;

                   CDR ;

                   CAR ;

                   SUB ;

                   ISNAT ;

                   { IF_NONE { PUSH int 122 ; FAILWITH } {} } ;

                   DUP 6 ;

                   CAR ;

                   CAR ;

                   PAIR ;

                   GET ;

                   { IF_NONE { PUSH int 122 ; FAILWITH } {} } ;

                   CDR ;

                   COMPARE ;

                   NEQ ;

                   IF

                     { UNPAIR ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       DUP 7 ;

                       CAR ;

                       CDR ;

                       CDR ;

                       LEVEL ;

                       PAIR %fromBlock %balance ;

                       SOME ;

                       DIG 7 ;

                       DUP ;

                       CAR ;

                       CDR ;

                       CAR ;

                       SWAP ;

                       DUP ;

                       DUG 9 ;

                       CAR ;

                       CAR ;

                       PAIR ;

                       UPDATE ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       UNPAIR ;

                       UNPAIR ;

                       SWAP ;

                       PUSH nat 1 ;

                       DUP 7 ;

                       CAR ;

                       CDR ;

                       CAR ;

                       ADD ;

                       SOME ;

                       DIG 6 ;

                       CAR ;

                       CAR ;

                       UPDATE ;

                       SWAP ;

                       PAIR ;

                       PAIR ;

                       SWAP ;

                       PAIR }

                     { DIG 2 ; DROP } } } ;

           UNIT ;

           PAIR %result %storage ;

           SWAP ;

           PAIR %operations } ;

       SWAP ;

       UNPAIR ;

       IF_LEFT

         { IF_LEFT

             { IF_LEFT

                 { DIG 2 ;

                   DROP ;

                   SWAP ;

                   DUP ;

                   DUG 2 ;

                   CAR ;

                   CDR ;

                   CAR ;

                   SENDER ;

                   MEM ;

                   IF

                     {}

                     { SWAP ;

                       UNPAIR ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       PUSH (option nat) (Some 0) ;

                       SENDER ;

                       UPDATE ;

                       PAIR ;

                       SWAP ;

                       UNPAIR ;

                       SWAP ;

                       PUSH (option (map address nat)) (Some {}) ;

                       SENDER ;

                       UPDATE ;

                       SWAP ;

                       PAIR ;

                       PAIR ;

                       PAIR ;

                       SWAP } ;

                   SWAP ;

                   DUP ;

                   DUG 2 ;

                   GET 5 ;

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

                   PUSH nat 0 ;

                   DUP 3 ;

                   CAR ;

                   CAR ;

                   CDR ;

                   SENDER ;

                   GET ;

                   { IF_NONE { PUSH int 239 ; FAILWITH } {} } ;

                   DUP 3 ;

                   CAR ;

                   GET ;

                   { IF_NONE { PUSH nat 0 } {} } ;

                   COMPARE ;

                   EQ ;

                   IF { PUSH bool True } { DUP ; CDR ; PUSH nat 0 ; COMPARE ; EQ } ;

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

                   SWAP ;

                   UNPAIR ;

                   UNPAIR ;

                   UNPAIR ;

                   SWAP ;

                   DUP ;

                   SENDER ;

                   DUP ;

                   DUG 2 ;

                   GET ;

                   { IF_NONE { PUSH int 241 ; FAILWITH } {} } ;

                   DUP 7 ;

                   CDR ;

                   SOME ;

                   DIG 7 ;

                   CAR ;

                   UPDATE ;

                   SOME ;

                   SWAP ;

                   UPDATE ;

                   SWAP ;

                   PAIR ;

                   PAIR ;

                   PAIR ;

                   NIL operation }

                 { IF_LEFT

                     { DROP ;

                       SWAP ;

                       DROP ;

                       SENDER ;

                       SOME ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CAR ;

                       CAR ;

                       COMPARE ;

                       EQ ;

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

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       CDR ;

                       PUSH bool True ;

                       PAIR ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       NIL operation }

                     { DIG 2 ;

                       DROP ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CAR ;

                       CAR ;

                       NIL operation ;

                       DIG 2 ;

                       CDR ;

                       PUSH mutez 0 ;

                       DIG 3 ;

                       TRANSFER_TOKENS ;

                       CONS } } }

             { IF_LEFT

                 { DIG 2 ;

                   DROP ;

                   SWAP ;

                   DUP ;

                   DUG 2 ;

                   CAR ;

                   CDR ;

                   CAR ;

                   SWAP ;

                   DUP ;

                   DUG 2 ;

                   CAR ;

                   CAR ;

                   MEM ;

                   IF

                     {}

                     { SWAP ;

                       UNPAIR ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       PUSH (option nat) (Some 0) ;

                       DUP 6 ;

                       CAR ;

                       CAR ;

                       UPDATE ;

                       PAIR ;

                       SWAP ;

                       UNPAIR ;

                       SWAP ;

                       PUSH (option (map address nat)) (Some {}) ;

                       DUP 6 ;

                       CAR ;

                       CAR ;

                       UPDATE ;

                       SWAP ;

                       PAIR ;

                       PAIR ;

                       PAIR ;

                       SWAP } ;

                   SWAP ;

                   DUP ;

                   DUG 2 ;

                   CAR ;

                   CAR ;

                   CDR ;

                   SWAP ;

                   DUP ;

                   DUG 2 ;

                   CAR ;

                   CAR ;

                   GET ;

                   { IF_NONE { PUSH int 260 ; FAILWITH } {} } ;

                   SWAP ;

                   DUP ;

                   DUG 2 ;

                   CAR ;

                   CDR ;

                   GET ;

                   { IF_NONE { PUSH nat 0 } {} } ;

                   NIL operation ;

                   DIG 2 ;

                   CDR ;

                   PUSH mutez 0 ;

                   DIG 3 ;

                   TRANSFER_TOKENS ;

                   CONS }

                 { IF_LEFT

                     { DIG 2 ;

                       DROP ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CDR ;

                       CAR ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       MEM ;

                       IF

                         {}

                         { SWAP ;

                           UNPAIR ;

                           UNPAIR ;

                           SWAP ;

                           UNPAIR ;

                           PUSH (option nat) (Some 0) ;

                           DUP 6 ;

                           CAR ;

                           UPDATE ;

                           PAIR ;

                           SWAP ;

                           UNPAIR ;

                           SWAP ;

                           PUSH (option (map address nat)) (Some {}) ;

                           DUP 6 ;

                           CAR ;

                           UPDATE ;

                           SWAP ;

                           PAIR ;

                           PAIR ;

                           PAIR ;

                           SWAP } ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CDR ;

                       CAR ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       GET ;

                       { IF_NONE { PUSH int 253 ; FAILWITH } {} } ;

                       NIL operation ;

                       DIG 2 ;

                       CDR ;

                       PUSH mutez 0 ;

                       DIG 3 ;

                       TRANSFER_TOKENS ;

                       CONS }

                     { DUP ;

                       CAR ;

                       CDR ;

                       LEVEL ;

                       COMPARE ;

                       GT ;

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

                       PUSH nat 0 ;

                       DUP 3 ;

                       CDR ;

                       CAR ;

                       CDR ;

                       DUP 3 ;

                       CAR ;

                       CAR ;

                       GET ;

                       { IF_NONE { PUSH nat 0 } {} } ;

                       COMPARE ;

                       EQ ;

                       IF

                         { DIG 2 ;

                           DROP ;

                           DUP ;

                           CAR ;

                           CDR ;

                           PUSH nat 0 ;

                           SWAP ;

                           PAIR %level %result ;

                           SWAP ;

                           DUP ;

                           DUG 2 ;

                           CAR ;

                           CAR ;

                           PAIR %address }

                         { DUP ;

                           CAR ;

                           CDR ;

                           DUP 3 ;

                           CAR ;

                           CDR ;

                           CDR ;

                           CAR ;

                           PUSH nat 1 ;

                           DUP 5 ;

                           CDR ;

                           CAR ;

                           CDR ;

                           DUP 5 ;

                           CAR ;

                           CAR ;

                           GET ;

                           { IF_NONE { PUSH int 141 ; FAILWITH } {} } ;

                           SUB ;

                           ISNAT ;

                           { IF_NONE { PUSH int 141 ; FAILWITH } {} } ;

                           DUP 4 ;

                           CAR ;

                           CAR ;

                           PAIR ;

                           GET ;

                           { IF_NONE { PUSH int 141 ; FAILWITH } {} } ;

                           CAR ;

                           COMPARE ;

                           LE ;

                           IF

                             { DIG 2 ;

                               DROP ;

                               SWAP ;

                               DUP ;

                               DUG 2 ;

                               CAR ;

                               CDR ;

                               CDR ;

                               CAR ;

                               PUSH nat 1 ;

                               DUP 4 ;

                               CDR ;

                               CAR ;

                               CDR ;

                               DUP 4 ;

                               CAR ;

                               CAR ;

                               GET ;

                               { IF_NONE { PUSH int 143 ; FAILWITH } {} } ;

                               SUB ;

                               ISNAT ;

                               { IF_NONE { PUSH int 143 ; FAILWITH } {} } ;

                               DUP 3 ;

                               CAR ;

                               CAR ;

                               PAIR ;

                               GET ;

                               { IF_NONE { PUSH int 143 ; FAILWITH } {} } ;

                               CDR ;

                               SWAP ;

                               DUP ;

                               DUG 2 ;

                               CAR ;

                               CDR ;

                               PAIR %level %result ;

                               SWAP ;

                               DUP ;

                               DUG 2 ;

                               CAR ;

                               CAR ;

                               PAIR %address }

                             { DUP ;

                               CAR ;

                               CDR ;

                               DUP 3 ;

                               CAR ;

                               CDR ;

                               CDR ;

                               CAR ;

                               PUSH nat 0 ;

                               DUP 4 ;

                               CAR ;

                               CAR ;

                               PAIR ;

                               GET ;

                               { IF_NONE { PUSH int 149 ; FAILWITH } {} } ;

                               CAR ;

                               COMPARE ;

                               GT ;

                               IF

                                 { DIG 2 ;

                                   DROP ;

                                   DUP ;

                                   CAR ;

                                   CDR ;

                                   PUSH nat 0 ;

                                   SWAP ;

                                   PAIR %level %result ;

                                   SWAP ;

                                   DUP ;

                                   DUG 2 ;

                                   CAR ;

                                   CAR ;

                                   PAIR %address }

                                 { PUSH bool False ;

                                   PUSH nat 0 ;

                                   PUSH nat 0 ;

                                   PUSH nat 1 ;

                                   DUP 6 ;

                                   CDR ;

                                   CAR ;

                                   CDR ;

                                   DUP 6 ;

                                   CAR ;

                                   CAR ;

                                   GET ;

                                   { IF_NONE { PUSH int 160 ; FAILWITH } {} } ;

                                   SUB ;

                                   ISNAT ;

                                   { IF_NONE { PUSH int 160 ; FAILWITH } {} } ;

                                   SWAP ;

                                   DUP ;

                                   DUG 2 ;

                                   SWAP ;

                                   DUP ;

                                   DUG 2 ;

                                   COMPARE ;

                                   GT ;

                                   IF

                                     { PUSH bool False ; DUP 5 ; COMPARE ; EQ }

                                     { PUSH bool False } ;

                                   LOOP { DIG 2 ;

                                          DROP ;

                                          PUSH nat 2 ;

                                          DUP 3 ;

                                          DUP 3 ;

                                          SUB ;

                                          ISNAT ;

                                          { IF_NONE { PUSH int 164 ; FAILWITH } {} } ;

                                          EDIV ;

                                          { IF_NONE

                                              { PUSH int 164 ; FAILWITH }

                                              { CAR } } ;

                                          SWAP ;

                                          DUP ;

                                          DUG 2 ;

                                          SUB ;

                                          ISNAT ;

                                          { IF_NONE { PUSH int 164 ; FAILWITH } {} } ;

                                          DUG 2 ;

                                          DUP 5 ;

                                          CAR ;

                                          CDR ;

                                          DUP 7 ;

                                          CAR ;

                                          CDR ;

                                          CDR ;

                                          CAR ;

                                          DUP 5 ;

                                          DUP 8 ;

                                          CAR ;

                                          CAR ;

                                          PAIR ;

                                          GET ;

                                          { IF_NONE { PUSH int 167 ; FAILWITH } {} } ;

                                          CAR ;

                                          COMPARE ;

                                          EQ ;

                                          IF

                                            { DIG 3 ; DROP ; PUSH bool True ; DUG 3 }

                                            { DUP 5 ;

                                              CAR ;

                                              CDR ;

                                              DUP 7 ;

                                              CAR ;

                                              CDR ;

                                              CDR ;

                                              CAR ;

                                              DUP 5 ;

                                              DUP 8 ;

                                              CAR ;

                                              CAR ;

                                              PAIR ;

                                              GET ;

                                              { IF_NONE { PUSH int 170 ; FAILWITH } {} } ;

                                              CAR ;

                                              COMPARE ;

                                              LT ;

                                              IF

                                                { SWAP ; DROP ; SWAP ; DUP ; DUG 2 ; SWAP }

                                                { DROP ;

                                                  PUSH nat 1 ;

                                                  DUP 3 ;

                                                  SUB ;

                                                  ISNAT ;

                                                  { IF_NONE

                                                      { PUSH int 173 ; FAILWITH }

                                                      {} } } } ;

                                          SWAP ;

                                          DUP ;

                                          DUG 2 ;

                                          SWAP ;

                                          DUP ;

                                          DUG 2 ;

                                          COMPARE ;

                                          GT ;

                                          IF

                                            { PUSH bool False ; DUP 5 ; COMPARE ; EQ }

                                            { PUSH bool False } } ;

                                   DROP ;

                                   PUSH bool True ;

                                   DUP 4 ;

                                   COMPARE ;

                                   EQ ;

                                   IF

                                     { DROP ;

                                       SWAP ;

                                       DROP ;

                                       DIG 3 ;

                                       DROP ;

                                       DUP 3 ;

                                       CAR ;

                                       CDR ;

                                       CDR ;

                                       CAR ;

                                       SWAP ;

                                       DUP 3 ;

                                       CAR ;

                                       CAR ;

                                       PAIR ;

                                       GET ;

                                       { IF_NONE { PUSH int 179 ; FAILWITH } {} } ;

                                       CDR ;

                                       SWAP ;

                                       DUP ;

                                       DUG 2 ;

                                       CAR ;

                                       CDR ;

                                       PAIR %level %result ;

                                       SWAP ;

                                       DUP ;

                                       DUG 2 ;

                                       CAR ;

                                       CAR ;

                                       PAIR %address }

                                     { SWAP ;

                                       DROP ;

                                       SWAP ;

                                       DROP ;

                                       DIG 3 ;

                                       DROP ;

                                       DUP 3 ;

                                       CAR ;

                                       CDR ;

                                       CDR ;

                                       CAR ;

                                       SWAP ;

                                       DUP 3 ;

                                       CAR ;

                                       CAR ;

                                       PAIR ;

                                       GET ;

                                       { IF_NONE { PUSH int 188 ; FAILWITH } {} } ;

                                       CDR ;

                                       SWAP ;

                                       DUP ;

                                       DUG 2 ;

                                       CAR ;

                                       CDR ;

                                       PAIR %level %result ;

                                       SWAP ;

                                       DUP ;

                                       DUG 2 ;

                                       CAR ;

                                       CAR ;

                                       PAIR %address } } } } ;

                       NIL operation ;