parameter (or

            (or

              (or

                (pair %balance_of

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

                  (contract %callback (list (pair

                                            (pair %request (address %owner)

                                                           (nat %token_id))

                                            (nat %balance)))))

                (unit %claim))

              (or (lambda %execute unit (list operation))

                  (pair %remove_administrator (address %administrator_to_remove)

                                              (nat %token_id))))

            (or

              (or

                (pair %set_administrator (address %administrator_to_set) (nat %token_id))

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

              (or

                (list %transfer (pair (address %from_)

                                     (list %txs (pair (address %to_)

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

                (or

                  (list %update_operators (or

                                           (pair %add_operator (address %owner)

                                                               (pair (address %operator)

                                                                     (nat %token_id)))

                                           (pair %remove_operator (address %owner)

                                                                  (pair

                                                                    (address %operator)

                                                                    (nat %token_id)))))

                  (pair %update_stake (address %address) (nat %amount))))));

storage (pair

          (pair

            (pair (big_map %administrators (pair (address %owner) (nat %token_id)) unit)

                  (pair (nat %dist_factor) (big_map %dist_factors address nat)))

            (pair (timestamp %epoch_start_timestamp)

                  (pair (timestamp %last_update_timestamp)

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

          (pair

            (pair

              (big_map %operators

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

                unit)

              (pair (big_map %stakes address nat)

                    (big_map %token_metadata nat

                                             (pair (nat %token_id)

                                                   (map %token_info string bytes)))))

            (pair (nat %total_stake)

                  (pair (big_map %total_supply nat nat)

                        (pair %treasury_ledger_key (address %owner) (nat %token_id))))));

code { CAST (pair

              (or

                (or

                  (or

                    (pair (list (pair address nat))

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

                    unit)

                  (or (lambda unit (list operation)) (pair address nat)))

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

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

                        (or

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

                                   (pair address (pair address nat))))

                          (pair address nat)))))

              (pair

                (pair

                  (pair (big_map (pair address nat) unit)

                        (pair nat (big_map address nat)))

                  (pair timestamp (pair timestamp (big_map (pair address nat) nat))))

                (pair

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

                        (pair (big_map address nat)

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

                  (pair nat (pair (big_map nat nat) (pair address nat)))))) ;

       LAMBDA

         (pair address

               (pair

                 (pair

                   (pair (big_map (pair address nat) unit)

                         (pair nat (big_map address nat)))

                   (pair timestamp (pair timestamp (big_map (pair address nat) nat))))

                 (pair

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

                         (pair (big_map address nat)

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

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

         (pair (list operation)

               (pair unit

                     (pair

                       (pair

                         (pair (big_map (pair address nat) unit)

                               (pair nat (big_map address nat)))

                         (pair timestamp

                               (pair timestamp (big_map (pair address nat) nat))))

                       (pair

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

                               (pair (big_map address nat)

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

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

         { NIL operation ;

           SWAP ;

           DUP ;

           DUG 2 ;

           CDR ;

           DUP ;

           GET 3 ;

           GET 3 ;

           DUP 4 ;

           CAR ;

           MEM ;

           IF

             { DUP ;

               CAR ;

               CAR ;

               GET 4 ;

               PUSH nat 1000000000000 ;

               SWAP ;

               DUP 5 ;

               CAR ;

               GET ;

               IF_NONE { PUSH int 129 ; FAILWITH } {} ;

               DUP 3 ;

               CAR ;

               CAR ;

               GET 3 ;

               SUB ;

               ISNAT ;

               IF_NONE { PUSH int 129 ; FAILWITH } {} ;

               DUP 3 ;

               GET 3 ;

               GET 3 ;

               DUP 6 ;

               CAR ;

               GET ;

               IF_NONE { PUSH int 129 ; FAILWITH } {} ;

               MUL ;

               EDIV ;

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

               SWAP ;

               DUP ;

               DUG 2 ;

               UNPAIR ;

               UNPAIR ;

               SWAP ;

               UNPAIR ;

               SWAP ;

               UNPAIR ;

               SWAP ;

               DUP 6 ;

               DIG 7 ;

               CAR ;

               GET 6 ;

               PUSH nat 0 ;

               DUP 11 ;

               CAR ;

               PAIR ;

               GET ;

               IF_NONE { PUSH nat 0 } {} ;

               ADD ;

               SOME ;

               PUSH nat 0 ;

               DUP 10 ;

               CAR ;

               PAIR ;

               UPDATE ;

               SWAP ;

               PAIR ;

               SWAP ;

               PAIR ;

               SWAP ;

               PAIR ;

               PAIR ;

               DUP ;

               GET 7 ;

               DUP ;

               PUSH nat 0 ;

               DUP ;

               DUG 2 ;

               GET ;

               IF_NONE { PUSH int 135 ; FAILWITH } {} ;

               DIG 4 ;

               ADD ;

               SOME ;

               SWAP ;

               UPDATE ;

               UPDATE 7 ;

               DUP ;

               UNPAIR ;

               UNPAIR ;

               UNPAIR ;

               SWAP ;

               UNPAIR ;

               SWAP ;

               DIG 5 ;

               CAR ;

               CAR ;

               GET 3 ;

               SOME ;

               DIG 7 ;

               CAR ;

               UPDATE ;

               SWAP ;

               PAIR ;

               SWAP ;

               PAIR ;

               PAIR ;

               PAIR }

             { DIG 2 ; DROP } ;

           UNIT ;

           DIG 2 ;

           PAIR 3 } ;

       SWAP ;

       LAMBDA

         (pair unit

               (pair

                 (pair

                   (pair (big_map (pair address nat) unit)

                         (pair nat (big_map address nat)))

                   (pair timestamp (pair timestamp (big_map (pair address nat) nat))))

                 (pair

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

                         (pair (big_map address nat)

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

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

         (pair (list operation)

               (pair unit

                     (pair

                       (pair

                         (pair (big_map (pair address nat) unit)

                               (pair nat (big_map address nat)))

                         (pair timestamp

                               (pair timestamp (big_map (pair address nat) nat))))

                       (pair

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

                               (pair (big_map address nat)

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

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

         { NIL operation ;

           SWAP ;

           CDR ;

           DUP ;

           GET 5 ;

           PUSH nat 0 ;

           COMPARE ;

           LT ;

           IF

             { PUSH nat 0 ;

               PUSH nat 0 ;

               PUSH nat 31449600 ;

               DUP 4 ;

               CAR ;

               GET 3 ;

               NOW ;

               SUB ;

               ISNAT ;

               IF_NONE { PUSH int 87 ; FAILWITH } {} ;

               EDIV ;

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

               PUSH nat 31449600 ;

               DIG 4 ;

               DUP ;

               CAR ;

               GET 3 ;

               SWAP ;

               DUP ;

               DUG 6 ;

               CAR ;

               GET 5 ;

               SUB ;

               ISNAT ;

               IF_NONE { PUSH int 86 ; FAILWITH } {} ;

               EDIV ;

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

               DUP ;

               DUP 3 ;

               COMPARE ;

               GT ;

               LOOP { DIG 3 ;

                      DROP ;

                      DUP 4 ;

                      CAR ;

                      GET 3 ;

                      PUSH nat 31449600 ;

                      PUSH nat 1 ;

                      DUP 4 ;

                      ADD ;

                      MUL ;

                      INT ;

                      ADD ;

                      SWAP ;

                      DUP ;

                      DUG 2 ;

                      PUSH nat 66137566137 ;

                      LSR ;

                      DUP 6 ;

                      CAR ;

                      GET 5 ;

                      DUP 3 ;

                      SUB ;

                      ISNAT ;

                      IF_NONE { PUSH int 93 ; FAILWITH } {} ;

                      MUL ;

                      DUG 4 ;

                      PUSH nat 3 ;

                      DUP 6 ;

                      LSR ;

                      DIG 4 ;

                      ADD ;

                      DUG 3 ;

                      DUP 6 ;

                      UNPAIR ;

                      UNPAIR ;

                      UNPAIR ;

                      SWAP ;

                      UNPAIR ;

                      DIG 10 ;

                      GET 5 ;

                      PUSH nat 1000000000000 ;

                      DUP 12 ;

                      MUL ;

                      EDIV ;

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

                      ADD ;

                      PAIR ;

                      SWAP ;

                      PAIR ;

                      SWAP ;

                      UNPAIR ;

                      SWAP ;

                      CDR ;

                      DIG 4 ;

                      PAIR ;

                      SWAP ;

                      PAIR ;

                      SWAP ;

                      PAIR ;

                      PAIR ;

                      DUG 4 ;

                      PUSH nat 1 ;

                      ADD ;

                      DUP ;

                      DUP 3 ;

                      COMPARE ;

                      GT } ;

               DROP 2 ;

               SWAP ;

               DROP ;

               PUSH nat 31449600 ;

               DUP 3 ;

               CAR ;

               GET 3 ;

               NOW ;

               SUB ;

               ISNAT ;

               IF_NONE { PUSH int 87 ; FAILWITH } {} ;

               EDIV ;

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

               PUSH nat 66137566137 ;

               LSR ;

               DUP 3 ;

               CAR ;

               GET 5 ;

               NOW ;

               SUB ;

               ISNAT ;

               IF_NONE { PUSH int 102 ; FAILWITH } {} ;

               MUL ;

               SWAP ;

               PUSH nat 3 ;

               DUP 3 ;

               LSR ;

               ADD ;

               DUP 3 ;

               UNPAIR ;

               UNPAIR ;

               SWAP ;

               UNPAIR ;

               SWAP ;

               UNPAIR ;

               SWAP ;

               DUP ;

               DIG 8 ;

               GET 8 ;

               DUP ;

               DUG 2 ;

               GET ;

               IF_NONE { PUSH int 106 ; FAILWITH } {} ;

               DUP 8 ;

               ADD ;

               SOME ;

               SWAP ;

               UPDATE ;

               SWAP ;

               PAIR ;

               SWAP ;

               PAIR ;

               SWAP ;

               PAIR ;

               PAIR ;

               DUP ;

               GET 7 ;

               DUP ;

               PUSH nat 0 ;

               DUP ;

               DUG 2 ;

               GET ;

               IF_NONE { PUSH int 107 ; FAILWITH } {} ;

               DIG 4 ;

               ADD ;

               SOME ;

               SWAP ;

               UPDATE ;

               UPDATE 7 ;

               DUP ;

               DUG 2 ;

               UNPAIR ;

               UNPAIR ;

               UNPAIR ;

               SWAP ;

               UNPAIR ;

               DIG 6 ;

               GET 5 ;

               PUSH nat 1000000000000 ;

               DIG 7 ;

               MUL ;

               EDIV ;

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

               ADD ;

               PAIR ;

               SWAP ;

               PAIR ;

               SWAP ;

               UNPAIR ;

               SWAP ;

               CDR ;

               NOW ;

               PAIR ;

               SWAP ;

               PAIR ;

               SWAP ;

               PAIR ;

               PAIR }

             {} ;

           UNIT ;

           DIG 2 ;

           PAIR 3 } ;

       SWAP ;

       LAMBDA

         (pair nat

               (pair

                 (pair

                   (pair (big_map (pair address nat) unit)

                         (pair nat (big_map address nat)))

                   (pair timestamp (pair timestamp (big_map (pair address nat) nat))))

                 (pair

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

                         (pair (big_map address nat)

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

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

         (pair (list operation)

               (pair unit

                     (pair

                       (pair

                         (pair (big_map (pair address nat) unit)

                               (pair nat (big_map address nat)))

                         (pair timestamp

                               (pair timestamp (big_map (pair address nat) nat))))

                       (pair

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

                               (pair (big_map address nat)

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

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

         { NIL operation ;

           SWAP ;

           DUP ;

           DUG 2 ;

           CDR ;

           DUP ;

           CAR ;

           CAR ;

           CAR ;

           DIG 3 ;

           CAR ;

           SENDER ;

           PAIR ;

           MEM ;

           IF {} { PUSH int 401 ; FAILWITH } ;

           UNIT ;

           DIG 2 ;

           PAIR 3 } ;

       SWAP ;

       UNPAIR ;

       IF_LEFT

         { IF_LEFT

             { IF_LEFT

                 { NIL (pair (pair address nat) nat) ;

                   SWAP ;

                   DUP ;

                   DUG 2 ;

                   CAR ;

                   ITER { DUP 4 ;

                          GET 3 ;

                          GET 4 ;

                          SWAP ;

                          DUP ;

                          DUG 2 ;

                          CDR ;

                          MEM ;

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

                          SWAP ;

                          DUP 4 ;

                          CAR ;

                          GET 6 ;

                          DUP 3 ;

                          GET ;

                          IF_NONE { PUSH nat 0 } {} ;

                          DIG 2 ;

                          PAIR ;

                          CONS } ;

                   DIG 3 ;

                   DROP ;

                   DIG 3 ;

                   DROP ;

                   DIG 3 ;

                   DROP ;

                   NIL operation ;

                   DIG 2 ;

                   CDR ;

                   PUSH mutez 0 ;

                   DIG 3 ;

                   TRANSFER_TOKENS ;

                   CONS }

                 { DUP 4 ;

                   DIG 2 ;

                   UNIT ;

                   PAIR ;

                   EXEC ;

                   DUP ;

                   GET 4 ;

                   DUG 2 ;

                   DUP ;

                   CAR ;

                   DUP 7 ;

                   DIG 4 ;

                   SENDER ;

                   PAIR ;

                   EXEC ;

                   DUP ;

                   GET 4 ;

                   DUG 4 ;

                   DUP ;

                   CAR ;

                   NIL operation ;

                   SWAP ;

                   ITER { CONS } ;

                   ITER { DIG 2 ; SWAP ; CONS ; SWAP } ;

                   DROP ;

                   SWAP ;

                   DROP ;

                   SWAP ;

                   DROP ;

                   DIG 2 ;

                   DROP ;

                   DIG 2 ;

                   DROP ;

                   DIG 2 ;

                   DROP } }

             { DIG 3 ;

               DROP ;

               DIG 3 ;

               DROP ;

               IF_LEFT

                 { DUG 2 ;

                   PUSH nat 0 ;

                   PAIR ;

                   EXEC ;

                   DUP ;

                   GET 4 ;

                   DUG 2 ;

                   CAR ;

                   SWAP ;

                   UNIT ;

                   EXEC ;

                   NIL operation ;

                   SWAP ;

                   ITER { CONS } ;

                   ITER { CONS } }

                 { DUP ;

                   DUG 3 ;

                   CDR ;

                   PAIR ;

                   EXEC ;

                   DUP ;

                   GET 4 ;

                   DUG 2 ;

                   CAR ;

                   DIG 2 ;

                   UNPAIR ;

                   UNPAIR ;

                   UNPAIR ;

                   NONE unit ;

                   DIG 6 ;

                   UPDATE ;

                   PAIR ;

                   PAIR ;

                   PAIR ;

                   SWAP } } }

         { IF_LEFT

             { DIG 3 ;

               DROP ;

               DIG 3 ;

               DROP ;

               IF_LEFT

                 { DUP ;

                   DUG 3 ;

                   CDR ;

                   PAIR ;

                   EXEC ;

                   DUP ;

                   GET 4 ;

                   DUG 2 ;

                   CAR ;

                   DIG 2 ;

                   UNPAIR ;

                   UNPAIR ;

                   UNPAIR ;

                   PUSH (option unit) (Some Unit) ;

                   DIG 6 ;

                   UPDATE ;

                   PAIR ;

                   PAIR ;

                   PAIR ;

                   SWAP }

                 { DUG 2 ;

                   PUSH nat 0 ;

                   PAIR ;

                   EXEC ;

                   DUP ;

                   GET 4 ;

                   DUG 2 ;

                   CAR ;

                   DUP 3 ;

                   CAR ;

                   GET 6 ;

                   DUP 3 ;

                   MEM ;

                   IF

                     {}

                     { DIG 2 ;

                       UNPAIR ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       SWAP ;

                       PUSH (option nat) (Some 0) ;

                       DUP 8 ;

                       UPDATE ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       PAIR ;

                       DUG 2 } ;

                   DUG 2 ;

                   UPDATE 8 ;

                   SWAP } }

             { IF_LEFT

                 { DUP ;

                   ITER { DUP ;

                          CDR ;

                          ITER { DUP ;

                                 GET 3 ;

                                 DUP 3 ;

                                 CAR ;

                                 PAIR ;

                                 SWAP ;

                                 DUP ;

                                 GET 3 ;

                                 SWAP ;

                                 DUP ;

                                 DUG 3 ;

                                 CAR ;

                                 PAIR ;

                                 DUP 3 ;

                                 GET 4 ;

                                 DUP 7 ;

                                 CAR ;

                                 GET 6 ;

                                 DUP 4 ;

                                 GET ;

                                 IF_NONE { PUSH nat 0 } {} ;

                                 COMPARE ;

                                 GE ;

                                 IF

                                   {}

                                   { PUSH string "FA2_INSUFFICIENT_BALANCE" ; FAILWITH } ;

                                 DUP 4 ;

                                 CAR ;

                                 SENDER ;

                                 COMPARE ;

                                 EQ ;

                                 IF

                                   { PUSH bool True }

                                   { DUP 6 ; GET 3 ; CAR ; DUP 4 ; GET 3 ; SENDER ; DUP 7 ; CAR ; PAIR 3 ; MEM } ;

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

                                 PUSH nat 0 ;

                                 DUP 4 ;

                                 GET 4 ;

                                 COMPARE ;

                                 GT ;

                                 IF

                                   { DUP 6 ;

                                     UNPAIR ;

                                     UNPAIR ;

                                     SWAP ;

                                     UNPAIR ;

                                     SWAP ;

                                     UNPAIR ;

                                     SWAP ;

                                     DUP 8 ;

                                     GET 4 ;

                                     DIG 11 ;

                                     CAR ;

                                     GET 6 ;

                                     DUP 9 ;

                                     GET ;

                                     IF_NONE { PUSH int 265 ; FAILWITH } {} ;

                                     SUB ;

                                     ISNAT ;

                                     IF_NONE { PUSH int 265 ; FAILWITH } {} ;

                                     SOME ;

                                     DUP 8 ;

                                     UPDATE ;

                                     SWAP ;

                                     PAIR ;

                                     SWAP ;

                                     PAIR ;

                                     SWAP ;

                                     PAIR ;

                                     PAIR ;

                                     DUP ;

                                     DUG 6 ;

                                     UNPAIR ;

                                     UNPAIR ;

                                     SWAP ;

                                     UNPAIR ;

                                     SWAP ;

                                     UNPAIR ;

                                     SWAP ;

                                     DUP 8 ;

                                     GET 4 ;

                                     DIG 11 ;

                                     CAR ;

                                     GET 6 ;

                                     DUP 8 ;

                                     GET ;

                                     IF_NONE { PUSH nat 0 } {} ;

                                     ADD ;

                                     SOME ;

                                     DIG 6 ;

                                     UPDATE ;

                                     SWAP ;

                                     PAIR ;

                                     SWAP ;

                                     PAIR ;

                                     SWAP ;

                                     PAIR ;

                                     PAIR ;

                                     DUG 4 ;

                                     PUSH nat 0 ;

                                     DUP 6 ;

                                     CAR ;

                                     GET 6 ;

                                     DUP 3 ;

                                     GET ;