parameter (or

            (or (or (unit %claim) (nat %deposit))

                (or (unit %internal_claim)

                    (or (nat %internal_deposit) (unit %internal_withdraw))))

            (or

              (or (address %propose_administrator)

                  (or (address %remove_administrator) (unit %set_administrator)))

              (or (nat %set_max_release_period)

                  (or

                    (list %set_reward_balance (pair

                                               (pair %request (address %owner)

                                                              (nat %token_id))

                                               (nat %balance)))

                    (unit %withdraw)))));

storage (pair

          (pair

            (pair (big_map %administrators address nat)

                  (pair (nat %current_reward_balance) (nat %dist_factor)))

            (pair (nat %last_reward_balance)

                  (pair (nat %max_release_period) (address %reward_token_address))))

          (pair

            (pair (nat %reward_token_id)

                  (pair (address %sender) (address %stake_token_address)))

            (pair (int %stake_token_id)

                  (pair

                    (big_map %stakes address

                                     (pair (timestamp %age_timestamp)

                                           (pair (nat %dist_factor) (nat %stake))))

                    (nat %total_stake)))));

code { LAMBDA

         (pair unit

               (pair (list operation)

                     (pair

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

                             (pair nat (pair nat address)))

                       (pair (pair nat (pair address address))

                             (pair int

                                   (pair

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

                                     nat))))))

         (pair unit

               (pair (list operation)

                     (pair

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

                             (pair nat (pair nat address)))

                       (pair (pair nat (pair address address))

                             (pair int

                                   (pair

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

                                     nat))))))

         { CDR ;

           UNPAIR ;

           SWAP ;

           DUP ;

           DUG 2 ;

           CAR ;

           GET 6 ;

           CONTRACT %balance_of (pair

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

                                  (contract %callback (list (pair

                                                            (pair %request

                                                              (address %owner)

                                                              (nat %token_id))

                                                            (nat %balance))))) ;

           IF_NONE { PUSH int 73 ; FAILWITH } {} ;

           PUSH mutez 0 ;

           SELF_ADDRESS ;

           CONTRACT %set_reward_balance (list (pair

                                               (pair %request (address %owner)

                                                              (nat %token_id))

                                               (nat %balance))) ;

           IF_NONE { PUSH int 76 ; FAILWITH } {} ;

           NIL (pair address nat) ;

           DUP 6 ;

           GET 3 ;

           CAR ;

           SELF_ADDRESS ;

           PAIR ;

           CONS ;

           PAIR ;

           TRANSFER_TOKENS ;

           CONS ;

           UNIT ;

           PAIR 3 } ;

       SWAP ;

       LAMBDA

         (pair unit

               (pair (list operation)

                     (pair

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

                             (pair nat (pair nat address)))

                       (pair (pair nat (pair address address))

                             (pair int

                                   (pair

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

                                     nat))))))

         (pair unit

               (pair (list operation)

                     (pair

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

                             (pair nat (pair nat address)))

                       (pair (pair nat (pair address address))

                             (pair int

                                   (pair

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

                                     nat))))))

         { UNPAIR 3 ;

           SWAP ;

           DIG 2 ;

           DUP ;

           GET 7 ;

           SWAP ;

           DUP ;

           DUG 4 ;

           GET 3 ;

           GET 3 ;

           MEM ;

           IF

             { DIG 2 ;

               DUP ;

               GET 7 ;

               SWAP ;

               DUP ;

               DUG 4 ;

               GET 3 ;

               GET 3 ;

               GET ;

               IF_NONE { PUSH int 131 ; FAILWITH } {} ;

               DUP ;

               GET 3 ;

               PUSH nat 1000000000000 ;

               SWAP ;

               DUP 6 ;

               CAR ;

               CAR ;

               GET 4 ;

               SUB ;

               ISNAT ;

               IF_NONE { PUSH int 140 ; FAILWITH } {} ;

               DUP 3 ;

               GET 4 ;

               MUL ;

               EDIV ;

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

               DIG 4 ;

               DUP ;

               CAR ;

               GET 5 ;

               SWAP ;

               DUP ;

               DUG 6 ;

               CAR ;

               GET 5 ;

               DUP 4 ;

               CAR ;

               NOW ;

               SUB ;

               ISNAT ;

               IF_NONE { PUSH int 133 ; FAILWITH } {} ;

               DUP ;

               DUP 3 ;

               COMPARE ;

               LE ;

               IF { DROP } { SWAP ; DROP } ;

               DUP 3 ;

               MUL ;

               EDIV ;

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

               DUP ;

               PUSH nat 0 ;

               SWAP ;

               DUP 4 ;

               SUB ;

               ISNAT ;

               IF_NONE { PUSH int 153 ; FAILWITH } {} ;

               COMPARE ;

               GT ;

               IF

                 { DIG 3 ;

                   DUP 6 ;

                   CAR ;

                   GET 6 ;

                   CONTRACT %transfer (list (pair (address %from_)

                                                 (list %txs (pair (address %to_)

                                                                 (pair (nat %token_id)

                                                                       (nat %amount)))))) ;

                   IF_NONE { PUSH int 36 ; FAILWITH } {} ;

                   PUSH mutez 0 ;

                   NIL (pair address (list (pair address (pair nat nat)))) ;

                   NIL (pair address (pair nat nat)) ;

                   DUP 6 ;

                   DUP 8 ;

                   SUB ;

                   ISNAT ;

                   IF_NONE { PUSH int 153 ; FAILWITH } {} ;

                   DUP 11 ;

                   GET 3 ;

                   CAR ;

                   SELF_ADDRESS ;

                   PAIR 3 ;

                   CONS ;

                   SELF_ADDRESS ;

                   PAIR ;

                   CONS ;

                   TRANSFER_TOKENS ;

                   CONS ;

                   DUG 3 }

                 {} ;

               DUP ;

               PUSH nat 0 ;

               COMPARE ;

               LT ;

               IF

                 { DIG 2 ;

                   DROP ;

                   DIG 3 ;

                   DROP ;

                   DIG 2 ;

                   DUP 4 ;

                   CAR ;

                   GET 6 ;

                   CONTRACT %transfer (list (pair (address %from_)

                                                 (list %txs (pair (address %to_)

                                                                 (pair (nat %token_id)

                                                                       (nat %amount)))))) ;

                   IF_NONE { PUSH int 36 ; FAILWITH } {} ;

                   PUSH mutez 0 ;

                   NIL (pair address (list (pair address (pair nat nat)))) ;

                   NIL (pair address (pair nat nat)) ;

                   DIG 5 ;

                   DIG 7 ;

                   DUP ;

                   GET 3 ;

                   CAR ;

                   SWAP ;

                   DUP ;

                   DUG 9 ;

                   GET 3 ;

                   GET 3 ;

                   PAIR 3 ;

                   CONS ;

                   SELF_ADDRESS ;

                   PAIR ;

                   CONS ;

                   TRANSFER_TOKENS ;

                   CONS ;

                   SWAP }

                 { DROP ; SWAP ; DROP ; DIG 2 ; DROP } ;

               DUP 3 ;

               UNPAIR ;

               UNPAIR ;

               SWAP ;

               CDR ;

               DIG 3 ;

               DIG 5 ;

               CAR ;

               GET 3 ;

               SUB ;

               ISNAT ;

               IF_NONE { PUSH int 163 ; FAILWITH } {} ;

               PAIR ;

               SWAP ;

               PAIR ;

               PAIR ;

               DUP ;

               DUG 2 ;

               DUP ;

               GET 7 ;

               DUP ;

               DUP 5 ;

               GET 3 ;

               GET 3 ;

               DUP ;

               DUG 2 ;

               GET ;

               IF_NONE { PUSH int 166 ; FAILWITH } {} ;

               DIG 5 ;

               CAR ;

               CAR ;

               GET 4 ;

               UPDATE 3 ;

               SOME ;

               SWAP ;

               UPDATE ;

               UPDATE 7 ;

               SWAP }

             { SWAP ; DROP } ;

           UNIT ;

           PAIR 3 } ;

       SWAP ;

       LAMBDA

         (pair unit

               (pair

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

                       (pair nat (pair nat address)))

                 (pair (pair nat (pair address address))

                       (pair int

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

         (pair unit

               (pair

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

                       (pair nat (pair nat address)))

                 (pair (pair nat (pair address address))

                       (pair int

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

         { CDR ;

           DUP ;

           GET 8 ;

           PUSH nat 0 ;

           COMPARE ;

           LT ;

           IF

             { DUP ;

               UNPAIR ;

               UNPAIR ;

               UNPAIR ;

               SWAP ;

               UNPAIR ;

               SWAP ;

               DUP 6 ;

               GET 8 ;

               PUSH nat 1000000000000 ;

               DIG 7 ;

               DUP ;

               CAR ;

               GET 3 ;

               SWAP ;

               CAR ;

               CAR ;

               GET 3 ;

               SUB ;

               ISNAT ;

               IF_NONE { PUSH int 113 ; FAILWITH } {} ;

               MUL ;

               EDIV ;

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

               ADD ;

               SWAP ;

               PAIR ;

               SWAP ;

               PAIR ;

               PAIR ;

               PAIR ;

               DUP ;

               UNPAIR ;

               UNPAIR ;

               SWAP ;

               CDR ;

               DIG 3 ;

               CAR ;

               CAR ;

               GET 3 ;

               PAIR ;

               SWAP ;

               PAIR ;

               PAIR }

             {} ;

           UNIT ;

           PAIR } ;

       SWAP ;

       LAMBDA

         unit

         unit

         { DROP ; SELF_ADDRESS ; SENDER ; COMPARE ; EQ ; IF {} { PUSH int 400 ; FAILWITH } ; UNIT } ;

       SWAP ;

       LAMBDA

         (pair unit

               (pair

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

                       (pair nat (pair nat address)))

                 (pair (pair nat (pair address address))

                       (pair int

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

         (pair unit

               (pair

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

                       (pair nat (pair nat address)))

                 (pair (pair nat (pair address address))

                       (pair int

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

         { CDR ;

           DUP ;

           CAR ;

           CAR ;

           CAR ;

           PUSH nat 1 ;

           SWAP ;

           SENDER ;

           GET ;

           IF_NONE { PUSH int 21 ; FAILWITH } {} ;

           COMPARE ;

           EQ ;

           IF {} { PUSH int 401 ; FAILWITH } ;

           UNIT ;

           PAIR } ;

       SWAP ;

       UNPAIR ;

       IF_LEFT

         { IF_LEFT

             { IF_LEFT

                 { DROP ;

                   SWAP ;

                   DROP ;

                   SWAP ;

                   DROP ;

                   SWAP ;

                   DROP ;

                   SWAP ;

                   DROP ;

                   AMOUNT ;

                   PUSH mutez 0 ;

                   COMPARE ;

                   EQ ;

                   IF {} { AMOUNT ; FAILWITH } ;

                   UNPAIR ;

                   SWAP ;

                   UNPAIR ;

                   UNPAIR ;

                   SWAP ;

                   CDR ;

                   SENDER ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   NIL operation ;

                   DIG 2 ;

                   UNIT ;

                   SWAP ;

                   DUG 3 ;

                   PAIR 3 ;

                   EXEC ;

                   CDR ;

                   UNPAIR ;

                   SELF %internal_claim ;

                   PUSH mutez 0 ;

                   UNIT ;

                   TRANSFER_TOKENS ;

                   CONS }

                 { DIG 2 ;

                   DROP ;

                   DIG 2 ;

                   DROP ;

                   DIG 2 ;

                   DROP ;

                   DIG 2 ;

                   DROP ;

                   AMOUNT ;

                   PUSH mutez 0 ;

                   COMPARE ;

                   EQ ;

                   IF {} { AMOUNT ; FAILWITH } ;

                   SWAP ;

                   UNPAIR ;

                   SWAP ;

                   UNPAIR ;

                   UNPAIR ;

                   SWAP ;

                   CDR ;

                   SENDER ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   SWAP ;

                   NIL operation ;

                   DIG 3 ;

                   UNIT ;

                   SWAP ;

                   DIG 4 ;

                   DIG 3 ;

                   DIG 3 ;

                   PAIR 3 ;

                   EXEC ;

                   CDR ;

                   UNPAIR ;

                   SWAP ;

                   DUG 2 ;

                   SELF %internal_deposit ;

                   PUSH mutez 0 ;

                   DIG 3 ;

                   TRANSFER_TOKENS ;

                   CONS } }

             { IF_LEFT

                 { DROP ;

                   SWAP ;

                   DROP ;

                   DIG 4 ;

                   DROP ;

                   AMOUNT ;

                   PUSH mutez 0 ;

                   COMPARE ;

                   EQ ;

                   IF {} { AMOUNT ; FAILWITH } ;

                   SWAP ;

                   UNIT ;

                   EXEC ;

                   DROP ;

                   SWAP ;

                   UNIT ;

                   SWAP ;

                   DUG 2 ;

                   PAIR ;

                   EXEC ;

                   CDR ;

                   NIL operation ;

                   DIG 2 ;

                   UNIT ;

                   SWAP ;

                   DUG 3 ;

                   PAIR 3 ;

                   EXEC ;

                   CDR ;

                   UNPAIR }

                 { IF_LEFT

                     { DIG 2 ;

                       DROP ;

                       DIG 4 ;

                       DROP ;

                       DIG 4 ;

                       DROP ;

                       AMOUNT ;

                       PUSH mutez 0 ;

                       COMPARE ;

                       EQ ;

                       IF {} { AMOUNT ; FAILWITH } ;

                       DIG 2 ;

                       UNIT ;

                       EXEC ;

                       DROP ;

                       DIG 2 ;

                       UNIT ;

                       SWAP ;

                       DIG 3 ;

                       DIG 2 ;

                       PAIR ;

                       EXEC ;

                       CDR ;

                       SWAP ;

                       DUP ;

                       PUSH nat 0 ;

                       COMPARE ;

                       LT ;

                       IF

                         { NIL operation ;

                           DUP 3 ;

                           GET 3 ;

                           GET 4 ;

                           CONTRACT %transfer (pair (address %from)

                                                    (pair (address %to) (nat %value))) ;

                           IF_NONE { PUSH int 19 ; FAILWITH } {} ;

                           PUSH mutez 0 ;

                           DUP 4 ;

                           SELF_ADDRESS ;

                           DUP 7 ;

                           GET 3 ;

                           GET 3 ;

                           PAIR 3 ;

                           TRANSFER_TOKENS ;

                           CONS }

                         { NIL operation } ;

                       DIG 2 ;

                       DUP ;

                       GET 7 ;

                       SWAP ;

                       DUP ;

                       DUG 4 ;

                       GET 3 ;

                       GET 3 ;

                       MEM ;

                       IF

                         { DIG 2 ;

                           DUP ;

                           GET 7 ;

                           SWAP ;

                           DUP ;

                           DUG 4 ;

                           GET 3 ;

                           GET 3 ;

                           GET ;

                           IF_NONE { PUSH int 237 ; FAILWITH } {} ;

                           DUP ;

                           GET 3 ;

                           PUSH nat 1000000000000 ;

                           SWAP ;

                           DUP 6 ;

                           CAR ;

                           CAR ;

                           GET 4 ;

                           SUB ;

                           ISNAT ;

                           IF_NONE { PUSH int 246 ; FAILWITH } {} ;

                           DUP 3 ;

                           GET 4 ;

                           MUL ;

                           EDIV ;

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

                           DUP 4 ;

                           DUP 3 ;

                           GET 4 ;

                           ADD ;

                           PUSH nat 1000000000000 ;

                           DIG 2 ;

                           MUL ;

                           EDIV ;

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

                           DUP 5 ;

                           CAR ;

                           CAR ;

                           GET 4 ;

                           SUB ;

                           ISNAT ;

                           IF_NONE { PUSH int 253 ; FAILWITH } {} ;

                           DUP 5 ;

                           DUP ;

                           GET 7 ;

                           DUP 6 ;

                           DUP 5 ;

                           GET 4 ;

                           ADD ;

                           DIG 3 ;

                           DUP 7 ;

                           DUP 6 ;

                           GET 4 ;

                           ADD ;

                           DUP 9 ;

                           CAR ;

                           GET 5 ;

                           DUP 7 ;

                           CAR ;

                           NOW ;

                           SUB ;

                           ISNAT ;

                           IF_NONE { PUSH int 239 ; FAILWITH } {} ;

                           DUP ;

                           DUP 3 ;

                           COMPARE ;

                           LE ;

                           IF { DROP } { SWAP ; DROP } ;

                           DIG 6 ;

                           GET 4 ;

                           MUL ;

                           EDIV ;

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

                           INT ;

                           PUSH int -1 ;

                           MUL ;

                           NOW ;

                           ADD ;

                           PAIR 3 ;

                           SOME ;

                           DIG 5 ;

                           GET 3 ;

                           GET 3 ;

                           UPDATE ;

                           UPDATE 7 ;

                           DUG 2 }

                         { DUP 3 ;

                           DUP ;

                           GET 7 ;

                           DUP 4 ;

                           DUP 6 ;

                           CAR ;

                           CAR ;

                           GET 4 ;

                           NOW ;

                           PAIR 3 ;

                           SOME ;

                           DIG 5 ;

                           GET 3 ;

                           GET 3 ;

                           UPDATE ;

                           UPDATE 7 ;

                           DUG 2 } ;

                       DIG 2 ;

                       DUP ;

                       GET 8 ;

                       DIG 3 ;

                       ADD ;

                       UPDATE 8 ;

                       SWAP }

                     { DROP ;

                       SWAP ;

                       DROP ;

                       DIG 4 ;

                       DROP ;

                       AMOUNT ;

                       PUSH mutez 0 ;

                       COMPARE ;

                       EQ ;

                       IF {} { AMOUNT ; FAILWITH } ;

                       SWAP ;

                       UNIT ;

                       EXEC ;

                       DROP ;

                       SWAP ;

                       UNIT ;

                       SWAP ;

                       DUG 2 ;

                       PAIR ;

                       EXEC ;

                       CDR ;

                       NIL operation ;

                       DIG 2 ;

                       UNIT ;

                       SWAP ;

                       DUG 3 ;

                       PAIR 3 ;

                       EXEC ;

                       CDR ;

                       UNPAIR ;

                       SWAP ;

                       DUP ;

                       GET 7 ;

                       SWAP ;

                       DUP ;

                       DUG 3 ;

                       GET 3 ;

                       GET 3 ;

                       GET ;

                       IF_NONE { PUSH int 328 ; FAILWITH } {} ;

                       DUP ;

                       GET 4 ;

                       PUSH nat 0 ;

                       COMPARE ;

                       LT ;

                       IF

                         { SWAP ;

                           DUP 3 ;

                           GET 3 ;

                           GET 4 ;

                           CONTRACT %transfer (pair (address %from)

                                                    (pair (address %to) (nat %value))) ;

                           IF_NONE { PUSH int 19 ; FAILWITH } {} ;

                           PUSH mutez 0 ;

                           DUP 4 ;

                           GET 4 ;

                           DUP 6 ;

                           GET 3 ;

                           GET 3 ;

                           SELF_ADDRESS ;

                           PAIR 3 ;

                           TRANSFER_TOKENS ;

                           CONS ;

                           SWAP }

                         {} ;

                       DUP 3 ;

                       SWAP ;

                       GET 4 ;

                       DIG 3 ;

                       GET 8 ;

                       SUB ;

                       ISNAT ;

                       IF_NONE { PUSH int 344 ; FAILWITH } {} ;

                       UPDATE 8 ;

                       DUP ;

                       DUG 2 ;

                       DUP ;

                       GET 7 ;

                       NONE (pair timestamp (pair nat nat)) ;

                       DIG 4 ;

                       GET 3 ;

                       GET 3 ;

                       UPDATE ;

                       UPDATE 7 ;

                       SWAP } } } }

         { IF_LEFT

             { IF_LEFT

                 { DIG 3 ;

                   DROP ;

                   DIG 3 ;

                   DROP ;

                   DIG 3 ;

                   DROP ;

                   DIG 3 ;

                   DROP ;

                   AMOUNT ;

                   PUSH mutez 0 ;

                   COMPARE ;

                   EQ ;

                   IF {} { AMOUNT ; FAILWITH } ;

                   DIG 2 ;

                   UNIT ;

                   SWAP ;

                   DIG 3 ;

                   DIG 2 ;

                   PAIR ;

                   EXEC ;

                   CDR ;

                   UNPAIR ;