parameter (or

            (or

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

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

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

              (or

                (or

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

                                      (contract nat))

                  (pair %getBalance address (contract nat)))

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

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

            (or

              (or (address %setAdministrator)

                  (or (nat %setDebtCeiling) (address %setGovernorContract)))

              (or

                (or (bool %setPause)

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

                (or (pair %updateContractMetadata string bytes)

                    (pair %updateTokenMetadata nat (map string bytes))))));

storage (pair

          (pair

            (pair (address %administrator)

                  (big_map %balances address

                                     (pair (map %approvals address nat) (nat %balance))))

            (pair (nat %debtCeiling) (address %governorContractAddress)))

          (pair (pair (big_map %metadata string bytes) (bool %paused))

                (pair (big_map %token_metadata nat (pair nat (map string bytes)))

                      (nat %totalSupply))));

code { DUP ;

       CDR ;

       SWAP ;

       CAR ;

       IF_LEFT

         { IF_LEFT

             { IF_LEFT

                 { SWAP ;

                   DUP ;

                   DUG 2 ;

                   CDR ;

                   CAR ;

                   CDR ;

                   IF { UNIT ; FAILWITH } {} ;

                   PUSH nat 0 ;

                   DIG 2 ;

                   DUP ;

                   DUG 3 ;

                   CAR ;

                   CAR ;

                   CDR ;

                   SENDER ;

                   GET ;

                   { IF_NONE { UNIT ; FAILWITH } {} } ;

                   CAR ;

                   DIG 2 ;

                   DUP ;

                   DUG 3 ;

                   CAR ;

                   GET ;

                   { IF_NONE { PUSH nat 0 } {} } ;

                   COMPARE ;

                   EQ ;

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

                   IF {} { PUSH int 23 ; FAILWITH } ;

                   SWAP ;

                   DUP ;

                   CDR ;

                   SWAP ;

                   CAR ;

                   DUP ;

                   CDR ;

                   SWAP ;

                   CAR ;

                   DUP ;

                   CAR ;

                   SWAP ;

                   CDR ;

                   DUP ;

                   SENDER ;

                   DUP ;

                   DUG 2 ;

                   GET ;

                   { IF_NONE { UNIT ; FAILWITH } {} } ;

                   DUP ;

                   CDR ;

                   SWAP ;

                   CAR ;

                   DIG 7 ;

                   DUP ;

                   CAR ;

                   SWAP ;

                   CDR ;

                   SOME ;

                   SWAP ;

                   UPDATE ;

                   PAIR ;

                   SOME ;

                   SWAP ;

                   UPDATE ;

                   SWAP ;

                   PAIR ;

                   PAIR ;

                   PAIR ;

                   NIL operation }

                 { IF_LEFT

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CAR ;

                       CAR ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH int 24 ; FAILWITH } ;

                       DUP ;

                       CDR ;

                       DIG 2 ;

                       DUP ;

                       DUG 3 ;

                       CAR ;

                       CAR ;

                       CDR ;

                       DIG 2 ;

                       DUP ;

                       DUG 3 ;

                       CAR ;

                       GET ;

                       { IF_NONE { UNIT ; FAILWITH } {} } ;

                       CDR ;

                       COMPARE ;

                       GE ;

                       IF {} { PUSH int 23 ; FAILWITH } ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       DUP ;

                       CDR ;

                       SWAP ;

                       CAR ;

                       DUP ;

                       CDR ;

                       SWAP ;

                       CAR ;

                       DUP ;

                       CAR ;

                       SWAP ;

                       CDR ;

                       DUP ;

                       DIG 5 ;

                       DUP ;

                       DUG 6 ;

                       CAR ;

                       DUP ;

                       DUG 2 ;

                       GET ;

                       { IF_NONE { UNIT ; FAILWITH } {} } ;

                       CAR ;

                       DIG 6 ;

                       DUP ;

                       DUG 7 ;

                       CDR ;

                       DIG 8 ;

                       CAR ;

                       CAR ;

                       CDR ;

                       DIG 8 ;

                       DUP ;

                       DUG 9 ;

                       CAR ;

                       GET ;

                       { IF_NONE { UNIT ; FAILWITH } {} } ;

                       CDR ;

                       SUB ;

                       ISNAT ;

                       { IF_NONE { UNIT ; FAILWITH } {} } ;

                       SWAP ;

                       PAIR ;

                       SOME ;

                       SWAP ;

                       UPDATE ;

                       SWAP ;

                       PAIR ;

                       PAIR ;

                       PAIR ;

                       DUP ;

                       DUG 2 ;

                       DUP ;

                       CAR ;

                       SWAP ;

                       CDR ;

                       DUP ;

                       CAR ;

                       SWAP ;

                       CDR ;

                       CAR ;

                       DIG 3 ;

                       CDR ;

                       DIG 4 ;

                       CDR ;

                       CDR ;

                       CDR ;

                       SUB ;

                       ISNAT ;

                       { IF_NONE { UNIT ; FAILWITH } {} } ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       NIL operation }

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CAR ;

                       CAR ;

                       NIL operation ;

                       DIG 2 ;

                       CDR ;

                       PUSH mutez 0 ;

                       DIG 3 ;

                       TRANSFER_TOKENS ;

                       CONS } } }

             { IF_LEFT

                 { IF_LEFT

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CAR ;

                       CDR ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CAR ;

                       GET ;

                       { IF_NONE { UNIT ; FAILWITH } {} } ;

                       CAR ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CDR ;

                       GET ;

                       { IF_NONE { UNIT ; FAILWITH } {} } ;

                       NIL operation ;

                       DIG 2 ;

                       CDR ;

                       PUSH mutez 0 ;

                       DIG 3 ;

                       TRANSFER_TOKENS ;

                       CONS }

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CAR ;

                       CDR ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       GET ;

                       { IF_NONE { UNIT ; FAILWITH } {} } ;

                       CDR ;

                       NIL operation ;

                       DIG 2 ;

                       CDR ;

                       PUSH mutez 0 ;

                       DIG 3 ;

                       TRANSFER_TOKENS ;

                       CONS } }

                 { IF_LEFT

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       CDR ;

                       CDR ;

                       CDR ;

                       NIL operation ;

                       DIG 2 ;

                       CDR ;

                       PUSH mutez 0 ;

                       DIG 3 ;

                       TRANSFER_TOKENS ;

                       CONS }

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CAR ;

                       CAR ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH int 24 ; FAILWITH } ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CAR ;

                       CDR ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       MEM ;

                       IF

                         {}

                         { SWAP ;

                           DUP ;

                           CDR ;

                           SWAP ;

                           CAR ;

                           DUP ;

                           CDR ;

                           SWAP ;

                           CAR ;

                           DUP ;

                           CAR ;

                           SWAP ;

                           CDR ;

                           DIG 4 ;

                           DUP ;

                           DUG 5 ;

                           CAR ;

                           PUSH (option (pair (map %approvals address nat) (nat %balance))) (Some (Pair {} 0)) ;

                           SWAP ;

                           UPDATE ;

                           SWAP ;

                           PAIR ;

                           PAIR ;

                           PAIR ;

                           SWAP } ;

                       SWAP ;

                       DUP ;

                       CDR ;

                       SWAP ;

                       CAR ;

                       DUP ;

                       CDR ;

                       SWAP ;

                       CAR ;

                       DUP ;

                       CAR ;

                       SWAP ;

                       CDR ;

                       DUP ;

                       DIG 5 ;

                       DUP ;

                       DUG 6 ;

                       CAR ;

                       DUP ;

                       DUG 2 ;

                       GET ;

                       { IF_NONE { UNIT ; FAILWITH } {} } ;

                       DUP ;

                       CAR ;

                       SWAP ;

                       CDR ;

                       DIG 7 ;

                       DUP ;

                       DUG 8 ;

                       CDR ;

                       ADD ;

                       SWAP ;

                       PAIR ;

                       SOME ;

                       SWAP ;

                       UPDATE ;

                       SWAP ;

                       PAIR ;

                       PAIR ;

                       PAIR ;

                       DUP ;

                       CAR ;

                       SWAP ;

                       CDR ;

                       DUP ;

                       CAR ;

                       SWAP ;

                       CDR ;

                       DUP ;

                       CAR ;

                       SWAP ;

                       CDR ;

                       DIG 4 ;

                       CDR ;

                       ADD ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       DUP ;

                       CAR ;

                       CDR ;

                       CAR ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CDR ;

                       CDR ;

                       CDR ;

                       COMPARE ;

                       LE ;

                       IF {} { PUSH int 20 ; FAILWITH } ;

                       NIL operation } } } }

         { IF_LEFT

             { IF_LEFT

                 { SWAP ;

                   DUP ;

                   DUG 2 ;

                   CAR ;

                   CDR ;

                   CDR ;

                   SENDER ;

                   COMPARE ;

                   EQ ;

                   IF {} { PUSH int 4 ; FAILWITH } ;

                   SWAP ;

                   DUP ;

                   CDR ;

                   SWAP ;

                   CAR ;

                   DUP ;

                   CDR ;

                   SWAP ;

                   CAR ;

                   CDR ;

                   DIG 3 ;

                   PAIR ;

                   PAIR ;

                   PAIR }

                 { IF_LEFT

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CDR ;

                       CDR ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH int 4 ; FAILWITH } ;

                       SWAP ;

                       DUP ;

                       CDR ;

                       SWAP ;

                       CAR ;

                       DUP ;

                       CAR ;

                       SWAP ;

                       CDR ;

                       CDR ;

                       DIG 3 ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       PAIR }

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CDR ;

                       CDR ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH int 4 ; FAILWITH } ;

                       SWAP ;

                       DUP ;

                       CDR ;

                       SWAP ;

                       CAR ;

                       DUP ;

                       CAR ;

                       SWAP ;

                       CDR ;

                       CAR ;

                       DIG 3 ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       PAIR } } }

             { IF_LEFT

                 { IF_LEFT

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CAR ;

                       CAR ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH int 24 ; FAILWITH } ;

                       SWAP ;

                       DUP ;

                       CAR ;

                       SWAP ;

                       CDR ;

                       DUP ;

                       CDR ;

                       SWAP ;

                       CAR ;

                       CAR ;

                       DIG 3 ;

                       SWAP ;

                       PAIR ;

                       PAIR ;

                       SWAP ;

                       PAIR }

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CAR ;

                       CAR ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF

                         { PUSH bool True }

                         { SWAP ;

                           DUP ;

                           DUG 2 ;

                           CDR ;

                           CAR ;

                           CDR ;

                           IF

                             { PUSH bool False }

                             { DUP ;

                               CAR ;

                               SENDER ;

                               COMPARE ;

                               EQ ;

                               IF

                                 { PUSH bool True }

                                 { DUP ;

                                   CDR ;

                                   CDR ;

                                   DIG 2 ;

                                   DUP ;

                                   DUG 3 ;

                                   CAR ;

                                   CAR ;

                                   CDR ;

                                   DIG 2 ;

                                   DUP ;

                                   DUG 3 ;

                                   CAR ;

                                   GET ;

                                   { IF_NONE { UNIT ; FAILWITH } {} } ;

                                   CAR ;

                                   SENDER ;

                                   GET ;

                                   { IF_NONE { UNIT ; FAILWITH } {} } ;

                                   COMPARE ;

                                   GE } } } ;

                       IF {} { PUSH int 22 ; FAILWITH } ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CAR ;

                       CDR ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CDR ;

                       CAR ;

                       MEM ;

                       IF

                         {}

                         { SWAP ;

                           DUP ;

                           CDR ;

                           SWAP ;

                           CAR ;

                           DUP ;

                           CDR ;

                           SWAP ;

                           CAR ;

                           DUP ;

                           CAR ;

                           SWAP ;

                           CDR ;

                           DIG 4 ;

                           DUP ;

                           DUG 5 ;

                           CDR ;

                           CAR ;

                           PUSH (option (pair (map %approvals address nat) (nat %balance))) (Some (Pair {} 0)) ;

                           SWAP ;

                           UPDATE ;

                           SWAP ;

                           PAIR ;

                           PAIR ;

                           PAIR ;

                           SWAP } ;

                       DUP ;

                       CDR ;

                       CDR ;

                       DIG 2 ;

                       DUP ;

                       DUG 3 ;

                       CAR ;

                       CAR ;

                       CDR ;

                       DIG 2 ;

                       DUP ;

                       DUG 3 ;

                       CAR ;

                       GET ;

                       { IF_NONE { UNIT ; FAILWITH } {} } ;

                       CDR ;

                       COMPARE ;

                       GE ;

                       IF {} { PUSH int 23 ; FAILWITH } ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       DUP ;

                       CDR ;

                       SWAP ;

                       CAR ;

                       DUP ;

                       CDR ;

                       SWAP ;

                       CAR ;

                       DUP ;

                       CAR ;

                       SWAP ;

                       CDR ;

                       DUP ;

                       DIG 5 ;

                       DUP ;

                       DUG 6 ;

                       CAR ;

                       DUP ;

                       DUG 2 ;

                       GET ;

                       { IF_NONE { UNIT ; FAILWITH } {} } ;

                       CAR ;

                       DIG 6 ;

                       DUP ;

                       DUG 7 ;

                       CDR ;

                       CDR ;

                       DIG 8 ;

                       CAR ;

                       CAR ;

                       CDR ;

                       DIG 8 ;

                       DUP ;

                       DUG 9 ;

                       CAR ;

                       GET ;

                       { IF_NONE { UNIT ; FAILWITH } {} } ;

                       CDR ;

                       SUB ;

                       ISNAT ;

                       { IF_NONE { UNIT ; FAILWITH } {} } ;

                       SWAP ;

                       PAIR ;

                       SOME ;

                       SWAP ;

                       UPDATE ;

                       SWAP ;

                       PAIR ;

                       PAIR ;

                       PAIR ;

                       DUP ;

                       CDR ;

                       SWAP ;

                       CAR ;

                       DUP ;

                       CDR ;

                       SWAP ;

                       CAR ;

                       DUP ;

                       CAR ;

                       SWAP ;

                       CDR ;

                       DUP ;

                       DIG 5 ;

                       DUP ;

                       DUG 6 ;

                       CDR ;

                       CAR ;

                       DUP ;

                       DUG 2 ;

                       GET ;

                       { IF_NONE { UNIT ; FAILWITH } {} } ;

                       DUP ;

                       CAR ;

                       SWAP ;

                       CDR ;

                       DIG 7 ;

                       DUP ;

                       DUG 8 ;

                       CDR ;

                       CDR ;

                       ADD ;

                       SWAP ;

                       PAIR ;

                       SOME ;

                       SWAP ;

                       UPDATE ;

                       SWAP ;

                       PAIR ;

                       PAIR ;

                       PAIR ;

                       SWAP ;

                       DUP ;

                       CAR ;

                       SENDER ;

                       COMPARE ;

                       NEQ ;

                       IF

                         { SWAP ; DUP ; DUG 2 ; CAR ; CAR ; CAR ; SENDER ; COMPARE ; NEQ }

                         { PUSH bool False } ;

                       IF

                         { SWAP ;

                           DUP ;

                           DUG 2 ;

                           DUP ;

                           CDR ;

                           SWAP ;

                           CAR ;

                           DUP ;

                           CDR ;

                           SWAP ;

                           CAR ;

                           DUP ;

                           CAR ;

                           SWAP ;

                           CDR ;

                           DUP ;

                           DIG 5 ;

                           DUP ;

                           DUG 6 ;

                           CAR ;

                           DUP ;

                           DUG 2 ;

                           GET ;

                           { IF_NONE { UNIT ; FAILWITH } {} } ;

                           DUP ;

                           CDR ;

                           SWAP ;

                           CAR ;

                           SENDER ;

                           DIG 8 ;

                           DUP ;

                           DUG 9 ;

                           CDR ;

                           CDR ;

                           DIG 10 ;

                           CAR ;

                           CAR ;

                           CDR ;

                           DIG 10 ;

                           CAR ;

                           GET ;

                           { IF_NONE { UNIT ; FAILWITH } {} } ;

                           CAR ;

                           SENDER ;

                           GET ;

                           { IF_NONE { UNIT ; FAILWITH } {} } ;

                           SUB ;

                           ISNAT ;

                           { IF_NONE { UNIT ; FAILWITH } {} } ;

                           SOME ;

                           SWAP ;

                           UPDATE ;

                           PAIR ;

                           SOME ;

                           SWAP ;

                           UPDATE ;

                           SWAP ;

                           PAIR ;

                           PAIR ;

                           PAIR }

                         { DROP } } }

                 { IF_LEFT

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CDR ;

                       CDR ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH int 4 ; FAILWITH } ;

                       SWAP ;

                       DUP ;

                       CAR ;

                       SWAP ;

                       CDR ;

                       DUP ;

                       CDR ;

                       SWAP ;

                       CAR ;

                       DUP ;

                       CDR ;

                       SWAP ;

                       CAR ;

                       DIG 4 ;

                       DUP ;

                       CAR ;

                       SWAP ;

                       CDR ;

                       SOME ;

                       SWAP ;

                       UPDATE ;

                       PAIR ;

                       PAIR ;

                       SWAP ;

                       PAIR }

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CDR ;

                       CDR ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH int 4 ; FAILWITH } ;

                       SWAP ;

                       DUP ;

                       CAR ;

                       SWAP ;

                       CDR ;

                       DUP ;

                       CAR ;

                       SWAP ;

                       CDR ;

                       DUP ;

                       CDR ;

                       SWAP ;

                       CAR ;

                       PUSH nat 0 ;

                       DIG 5 ;

                       SOME ;

                       SWAP ;

                       UPDATE ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR } } } ;

           NIL operation } ;

       PAIR }