{ parameter (or

              (or

                (or

                  (list %assign_metadata (pair (map %metadata string bytes)

                                              (nat %token_id)))

                  (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)))))

                    (pair %mint

                      (pair (address %address) (pair (nat %issuer_id) (nat %iteration)))

                      (pair (pair (map %metadata string bytes) (nat %royalties))

                            (pair

                              (list %royalties_split (pair (address %address) (nat %pct)))

                              (nat %token_id))))))

                (or (address %set_administrator)

                    (or (address %set_issuer) (big_map %set_metadata string bytes))))

              (or

                (or (bool %set_pause)

                    (or (address %set_signer) (address %set_treasury_address)))

                (or

                  (list %transfer (pair (address %from_)

                                       (list %txs (pair (address %to_)

                                                       (pair (nat %token_id)

                                                             (nat %amount))))))

                  (or (mutez %transfer_xtz_treasury)

                      (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))))))))) ;

  storage (pair

            (pair (pair (address %administrator) (nat %all_tokens))

                  (pair (address %issuer)

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

                              (big_map %metadata string bytes))))

            (pair

              (pair

                (big_map %operators

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

                  unit)

                (pair (bool %paused) (address %signer)))

              (pair

                (big_map %token_data nat

                                     (pair

                                       (pair (bool %assigned)

                                             (pair (nat %issuer_id) (nat %iteration)))

                                       (pair (address %minter)

                                             (pair (nat %royalties)

                                                   (list %royalties_split (pair

                                                                           (address %address)

                                                                           (nat %pct)))))))

                (pair

                  (big_map %token_metadata nat

                                           (pair (nat %token_id)

                                                 (map %token_info string bytes)))

                  (address %treasury_address))))) ;

  code { CAST (pair

                (or

                  (or

                    (or (list (pair (map string bytes) nat))

                        (or

                          (pair (list (pair address nat))

                                (contract (list (pair (pair address nat) nat))))

                          (pair (pair address (pair nat nat))

                                (pair (pair (map string bytes) nat)

                                      (pair (list (pair address nat)) nat)))))

                    (or address (or address (big_map string bytes))))

                  (or (or bool (or address address))

                      (or (list (pair address (list (pair address (pair nat nat)))))

                          (or mutez

                              (list (or (pair address (pair address nat))

                                       (pair address (pair address nat))))))))

                (pair

                  (pair (pair address nat)

                        (pair address

                              (pair (big_map (pair address nat) nat)

                                    (big_map string bytes))))

                  (pair

                    (pair (big_map (pair address (pair address nat)) unit)

                          (pair bool address))

                    (pair

                      (big_map nat

                               (pair (pair bool (pair nat nat))

                                     (pair address (pair nat (list (pair address nat))))))

                      (pair (big_map nat (pair nat (map string bytes))) address))))) ;

         UNPAIR ;

         IF_LEFT

           { IF_LEFT

               { IF_LEFT

                   { SWAP ;

                     DUP ;

                     DUG 2 ;

                     GET 3 ;

                     GET 4 ;

                     SENDER ;

                     COMPARE ;

                     EQ ;

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

                     DUP ;

                     ITER { DUP 3 ;

                            GET 5 ;

                            SWAP ;

                            DUP ;

                            DUG 2 ;

                            CDR ;

                            MEM ;

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

                            DIG 2 ;

                            DUP ;

                            GET 7 ;

                            DUP ;

                            DUP 4 ;

                            CDR ;

                            DUP ;

                            DUG 2 ;

                            GET ;

                            IF_NONE { PUSH int 527 ; FAILWITH } {} ;

                            DUP 5 ;

                            CAR ;

                            UPDATE 2 ;

                            SOME ;

                            SWAP ;

                            UPDATE ;

                            UPDATE 7 ;

                            DUP ;

                            GET 5 ;

                            DUP ;

                            DIG 3 ;

                            CDR ;

                            DUP ;

                            DUG 2 ;

                            GET ;

                            IF_NONE { PUSH int 528 ; FAILWITH } {} ;

                            UNPAIR ;

                            CDR ;

                            PUSH bool True ;

                            PAIR ;

                            PAIR ;

                            SOME ;

                            SWAP ;

                            UPDATE ;

                            UPDATE 5 ;

                            SWAP } ;

                     DROP ;

                     NIL operation }

                   { IF_LEFT

                       { SWAP ;

                         DUP ;

                         DUG 2 ;

                         GET 3 ;

                         GET 3 ;

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

                         DUP ;

                         CAR ;

                         MAP { DUP 3 ;

                               GET 7 ;

                               SWAP ;

                               DUP ;

                               DUG 2 ;

                               CDR ;

                               MEM ;

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

                               DUP 3 ;

                               CAR ;

                               GET 5 ;

                               SWAP ;

                               DUP ;

                               CDR ;

                               SWAP ;

                               DUP ;

                               DUG 3 ;

                               CAR ;

                               PAIR ;

                               MEM ;

                               IF

                                 { DUP 3 ;

                                   CAR ;

                                   GET 5 ;

                                   SWAP ;

                                   DUP ;

                                   CDR ;

                                   SWAP ;

                                   DUP ;

                                   DUG 3 ;

                                   CAR ;

                                   PAIR ;

                                   GET ;

                                   IF_NONE { PUSH int 352 ; FAILWITH } {} ;

                                   SWAP ;

                                   PAIR }

                                 { PUSH nat 0 ; SWAP ; PAIR } } ;

                         NIL operation ;

                         DIG 2 ;

                         CDR ;

                         PUSH mutez 0 ;

                         DIG 3 ;

                         TRANSFER_TOKENS ;

                         CONS }

                       { SWAP ;

                         DUP ;

                         DUG 2 ;

                         CAR ;

                         GET 3 ;

                         SENDER ;

                         COMPARE ;

                         EQ ;

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

                         SWAP ;

                         UNPAIR ;

                         UNPAIR ;

                         SWAP ;

                         UNPAIR ;

                         SWAP ;

                         UNPAIR ;

                         PUSH (option nat) (Some 1) ;

                         DIG 6 ;

                         DUP ;

                         GET 6 ;

                         SWAP ;

                         DUP ;

                         DUG 8 ;

                         CAR ;

                         CAR ;

                         PAIR ;

                         UPDATE ;

                         PAIR ;

                         SWAP ;

                         PAIR ;

                         SWAP ;

                         PAIR ;

                         PAIR ;

                         DUP ;

                         GET 7 ;

                         DIG 2 ;

                         DUP ;

                         GET 3 ;

                         CAR ;

                         SWAP ;

                         DUP ;

                         DUG 4 ;

                         GET 6 ;

                         PAIR ;

                         SOME ;

                         DUP 4 ;

                         GET 6 ;

                         UPDATE ;

                         UPDATE 7 ;

                         DUP ;

                         GET 5 ;

                         DIG 2 ;

                         DUP ;

                         GET 5 ;

                         SWAP ;

                         DUP ;

                         DUG 4 ;

                         GET 3 ;

                         CDR ;

                         PAIR ;

                         DUP 4 ;

                         CAR ;

                         CAR ;

                         PAIR ;

                         DIG 3 ;

                         DUP ;

                         CAR ;

                         GET 4 ;

                         SWAP ;

                         DUP ;

                         DUG 5 ;

                         CAR ;

                         GET 3 ;

                         PAIR ;

                         PUSH bool False ;

                         PAIR ;

                         PAIR ;

                         SOME ;

                         DIG 3 ;

                         GET 6 ;

                         UPDATE ;

                         UPDATE 5 ;

                         UNPAIR ;

                         UNPAIR ;

                         UNPAIR ;

                         SWAP ;

                         PUSH nat 1 ;

                         ADD ;

                         SWAP ;

                         PAIR ;

                         PAIR ;

                         PAIR ;

                         NIL operation } } }

               { IF_LEFT

                   { SWAP ;

                     DUP ;

                     DUG 2 ;

                     CAR ;

                     CAR ;

                     CAR ;

                     SENDER ;

                     COMPARE ;

                     EQ ;

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

                     SWAP ;

                     UNPAIR ;

                     UNPAIR ;

                     CDR ;

                     DIG 3 ;

                     PAIR ;

                     PAIR ;

                     PAIR }

                   { IF_LEFT

                       { SWAP ;

                         DUP ;

                         DUG 2 ;

                         CAR ;

                         CAR ;

                         CAR ;

                         SENDER ;

                         COMPARE ;

                         EQ ;

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

                         SWAP ;

                         UNPAIR ;

                         UNPAIR ;

                         SWAP ;

                         CDR ;

                         DIG 3 ;

                         PAIR ;

                         SWAP ;

                         PAIR ;

                         PAIR }

                       { SWAP ;

                         DUP ;

                         DUG 2 ;

                         CAR ;

                         CAR ;

                         CAR ;

                         SENDER ;

                         COMPARE ;

                         EQ ;

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

                         SWAP ;

                         UNPAIR ;

                         UNPAIR ;

                         SWAP ;

                         UNPAIR ;

                         SWAP ;

                         CAR ;

                         DIG 4 ;

                         SWAP ;

                         PAIR ;

                         SWAP ;

                         PAIR ;

                         SWAP ;

                         PAIR ;

                         PAIR } } ;

                 NIL operation } }

           { IF_LEFT

               { IF_LEFT

                   { SWAP ;

                     DUP ;

                     DUG 2 ;

                     CAR ;

                     CAR ;

                     CAR ;

                     SENDER ;

                     COMPARE ;

                     EQ ;

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

                     SWAP ;

                     UNPAIR ;

                     SWAP ;

                     UNPAIR ;

                     UNPAIR ;

                     SWAP ;

                     CDR ;

                     DIG 4 ;

                     PAIR ;

                     SWAP ;

                     PAIR ;

                     PAIR ;

                     SWAP ;

                     PAIR }

                   { IF_LEFT

                       { SWAP ;

                         DUP ;

                         DUG 2 ;

                         CAR ;

                         CAR ;

                         CAR ;

                         SENDER ;

                         COMPARE ;

                         EQ ;

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

                         SWAP ;

                         UNPAIR ;

                         SWAP ;

                         UNPAIR ;

                         UNPAIR ;

                         SWAP ;

                         CAR ;

                         DIG 4 ;

                         SWAP ;

                         PAIR ;

                         SWAP ;

                         PAIR ;

                         PAIR ;

                         SWAP ;

                         PAIR }

                       { SWAP ;

                         DUP ;

                         DUG 2 ;

                         CAR ;

                         CAR ;

                         CAR ;

                         SENDER ;

                         COMPARE ;

                         EQ ;

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

                         UPDATE 8 } } ;

                 NIL operation }

               { IF_LEFT

                   { SWAP ;

                     DUP ;

                     DUG 2 ;

                     GET 3 ;

                     GET 3 ;

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

                     DUP ;

                     ITER { DUP ;

                            CDR ;

                            ITER { SENDER ;

                                   DUP 3 ;

                                   CAR ;

                                   COMPARE ;

                                   EQ ;

                                   IF

                                     { PUSH bool True }

                                     { DUP 4 ;

                                       GET 3 ;

                                       CAR ;

                                       SWAP ;

                                       DUP ;

                                       DUG 2 ;

                                       GET 3 ;

                                       SENDER ;

                                       DUP 5 ;

                                       CAR ;

                                       PAIR 3 ;

                                       MEM } ;

                                   IF

                                     { PUSH bool True }

                                     { SELF_ADDRESS ; SENDER ; COMPARE ; EQ } ;

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

                                   DUP 4 ;

                                   GET 7 ;

                                   SWAP ;

                                   DUP ;

                                   DUG 2 ;

                                   GET 3 ;

                                   MEM ;

                                   IF

                                     {}

                                     { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH } ;

                                   DUP ;

                                   GET 4 ;

                                   PUSH nat 0 ;

                                   COMPARE ;

                                   LT ;

                                   IF

                                     { DUP ;

                                       GET 4 ;

                                       DUP 5 ;

                                       CAR ;

                                       GET 5 ;

                                       DUP 3 ;

                                       GET 3 ;

                                       DUP 5 ;

                                       CAR ;

                                       PAIR ;

                                       GET ;

                                       IF_NONE { PUSH int 331 ; FAILWITH } {} ;

                                       COMPARE ;

                                       GE ;

                                       IF

                                         {}

                                         { PUSH string "FA2_INSUFFICIENT_BALANCE" ;

                                           FAILWITH } ;

                                       DUP 4 ;

                                       UNPAIR ;

                                       UNPAIR ;

                                       SWAP ;

                                       UNPAIR ;

                                       SWAP ;

                                       UNPAIR ;

                                       DUP ;

                                       DUP 7 ;

                                       GET 3 ;

                                       DUP 9 ;

                                       CAR ;

                                       PAIR ;

                                       DUP ;

                                       DUG 2 ;

                                       GET ;

                                       IF_NONE { PUSH int 335 ; FAILWITH } { DROP } ;

                                       DUP 7 ;

                                       GET 4 ;

                                       DIG 10 ;

                                       CAR ;

                                       GET 5 ;

                                       DUP 9 ;

                                       GET 3 ;

                                       DUP 11 ;

                                       CAR ;

                                       PAIR ;

                                       GET ;

                                       IF_NONE { PUSH int 335 ; FAILWITH } {} ;

                                       SUB ;

                                       ISNAT ;

                                       IF_NONE { PUSH int 335 ; FAILWITH } {} ;

                                       SOME ;

                                       SWAP ;

                                       UPDATE ;

                                       PAIR ;

                                       SWAP ;

                                       PAIR ;

                                       SWAP ;

                                       PAIR ;

                                       PAIR ;

                                       DUP ;

                                       DUG 4 ;

                                       CAR ;

                                       GET 5 ;

                                       SWAP ;

                                       DUP ;

                                       GET 3 ;

                                       SWAP ;

                                       DUP ;

                                       DUG 3 ;

                                       CAR ;

                                       PAIR ;

                                       MEM ;

                                       IF

                                         { DIG 3 ;

                                           UNPAIR ;

                                           UNPAIR ;

                                           SWAP ;

                                           UNPAIR ;

                                           SWAP ;

                                           UNPAIR ;

                                           DUP ;

                                           DIG 6 ;

                                           DUP ;

                                           GET 3 ;

                                           SWAP ;

                                           DUP ;

                                           DUG 8 ;

                                           CAR ;

                                           PAIR ;

                                           DUP ;

                                           DUG 2 ;

                                           GET ;

                                           IF_NONE { PUSH int 337 ; FAILWITH } {} ;

                                           DIG 7 ;

                                           GET 4 ;

                                           ADD ;

                                           SOME ;

                                           SWAP ;

                                           UPDATE ;

                                           PAIR ;

                                           SWAP ;

                                           PAIR ;

                                           SWAP ;

                                           PAIR ;

                                           PAIR ;

                                           DUG 2 }

                                         { DIG 3 ;

                                           UNPAIR ;

                                           UNPAIR ;

                                           SWAP ;

                                           UNPAIR ;

                                           SWAP ;

                                           UNPAIR ;

                                           DUP 6 ;

                                           GET 4 ;

                                           SOME ;

                                           DIG 6 ;

                                           DUP ;

                                           GET 3 ;

                                           SWAP ;

                                           CAR ;

                                           PAIR ;

                                           UPDATE ;

                                           PAIR ;

                                           SWAP ;

                                           PAIR ;

                                           SWAP ;

                                           PAIR ;

                                           PAIR ;

                                           DUG 2 } }

                                     { DROP } } ;

                            DROP } ;

                     DROP ;

                     NIL operation }

                   { IF_LEFT

                       { SWAP ;

                         DUP ;

                         DUG 2 ;

                         CAR ;

                         CAR ;

                         CAR ;

                         SENDER ;

                         COMPARE ;

                         EQ ;

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

                         DUP ;

                         BALANCE ;

                         COMPARE ;

                         GE ;

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

                         NIL operation ;

                         DUP 3 ;

                         GET 8 ;

                         CONTRACT unit ;

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

                         DIG 2 ;

                         UNIT ;

                         TRANSFER_TOKENS ;

                         CONS }

                       { DUP ;

                         ITER { IF_LEFT

                                  { DUP ;

                                    CAR ;

                                    SENDER ;

                                    COMPARE ;

                                    EQ ;

                                    IF

                                      { PUSH bool True }

                                      { DUP 3 ; CAR ; CAR ; CAR ; SENDER ; COMPARE ; EQ } ;

                                    IF

                                      {}

                                      { PUSH string "FA2_NOT_ADMIN_OR_OPERATOR" ;

                                        FAILWITH } ;

                                    DIG 2 ;

                                    UNPAIR ;

                                    SWAP ;

                                    UNPAIR ;

                                    UNPAIR ;

                                    PUSH (option unit) (Some Unit) ;

                                    DIG 5 ;

                                    DUP ;

                                    GET 4 ;

                                    SWAP ;

                                    DUP ;

                                    GET 3 ;

                                    SWAP ;

                                    CAR ;

                                    PAIR 3 ;

                                    UPDATE ;

                                    PAIR ;

                                    PAIR ;

                                    SWAP ;

                                    PAIR ;

                                    SWAP }

                                  { DUP ;

                                    CAR ;

                                    SENDER ;

                                    COMPARE ;

                                    EQ ;

                                    IF

                                      { PUSH bool True }

                                      { DUP 3 ; CAR ; CAR ; CAR ; SENDER ; COMPARE ; EQ } ;

                                    IF

                                      {}

                                      { PUSH string "FA2_NOT_ADMIN_OR_OPERATOR" ;

                                        FAILWITH } ;

                                    DIG 2 ;

                                    UNPAIR ;

                                    SWAP ;

                                    UNPAIR ;

                                    UNPAIR ;

                                    NONE unit ;

                                    DIG 5 ;

                                    DUP ;

                                    GET 4 ;

                                    SWAP ;

                                    DUP ;

                                    GET 3 ;

                                    SWAP ;

                                    CAR ;

                                    PAIR 3 ;

                                    UPDATE ;

                                    PAIR ;

                                    PAIR ;

                                    SWAP ;

                                    PAIR ;

                                    SWAP } } ;

                         DROP ;

                         NIL operation } } } } ;

         PAIR } ;

  view "get_token_data" nat

        (pair (pair (nat %issuer_id) (nat %iteration))

              (pair (nat %royalties)

                    (list %royalties_split (pair (address %address) (nat %pct)))))

        { UNPAIR ;

          SWAP ;

          DUP ;

          DUG 2 ;

          GET 5 ;

          SWAP ;

          DUP ;

          DUG 2 ;

          GET ;

          IF_NONE { PUSH int 580 ; FAILWITH } {} ;

          GET 6 ;

          DUP 3 ;

          GET 5 ;

          DUP 3 ;

          GET ;

          IF_NONE { PUSH int 580 ; FAILWITH } {} ;

          GET 5 ;

          PAIR ;

          DUP 3 ;

          GET 5 ;

          DUP 3 ;

          GET ;

          IF_NONE { PUSH int 580 ; FAILWITH } {} ;

          CAR ;

          GET 4 ;

          DIG 3 ;

          GET 5 ;

          DIG 3 ;

          GET ;

          IF_NONE { PUSH int 580 ; FAILWITH } {} ;

          CAR ;

          GET 3 ;

          PAIR ;

          PAIR } ;

  view "minter" nat address

        { UNPAIR ; SWAP ; GET 5 ; SWAP ; GET ; IF_NONE { PUSH int 44 ; FAILWITH } {} ; GET 3 } ;

  view "royalty" nat nat

        { UNPAIR ; SWAP ; GET 5 ; SWAP ; GET ; IF_NONE { PUSH int 38 ; FAILWITH } {} ; GET 5 } ;

  view "royalty_distribution" nat

        (pair (address %minter)

              (pair (nat %royalty) (list %splits (pair (address %address) (nat %pct)))))

        { UNPAIR ;

          SWAP ;

          DUP ;

          DUG 2 ;

          GET 5 ;

          SWAP ;

          DUP ;

          DUG 2 ;

          GET ;

          IF_NONE { PUSH int 41 ; FAILWITH } {} ;

          GET 6 ;

          DUP 3 ;

          GET 5 ;

          DUP 3 ;

          GET ;

          IF_NONE { PUSH int 38 ; FAILWITH } {} ;

          GET 5 ;

          DIG 3 ;

          GET 5 ;

          DIG 3 ;

          GET ;

          IF_NONE { PUSH int 44 ; FAILWITH } {} ;

          GET 3 ;

          PAIR 3 } ;

  view "royalty_splits" nat

        (pair (nat %royalty) (list %splits (pair (address %address) (nat %pct))))

        { UNPAIR ;

          SWAP ;

          DUP ;

          DUG 2 ;

          GET 5 ;

          SWAP ;

          DUP ;

          DUG 2 ;

          GET ;

          IF_NONE { PUSH int 41 ; FAILWITH } {} ;

          GET 6 ;

          DIG 2 ;

          GET 5 ;

          DIG 2 ;

          GET ;

          IF_NONE { PUSH int 38 ; FAILWITH } {} ;

          GET 5 ;

          PAIR } ;

  view "splits" nat (list (pair (address %address) (nat %pct)))

        { UNPAIR ; SWAP ; GET 5 ; SWAP ; GET ; IF_NONE { PUSH int 41 ; FAILWITH } {} ; GET 6 } ;

  view "token_exists" nat bool { UNPAIR ; SWAP ; GET 5 ; SWAP ; MEM } }