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

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

                  (or

                    (list %set_reward_balance (pair

                                               (pair %request (address %owner)

                                                              (nat %token_id))

                                               (nat %balance)))

                    (unit %withdraw))));

storage (pair

          (pair

            (pair (nat %current_reward_balance)

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

            (pair (address %engine_address)

                  (pair (nat %last_reward_balance) (address %reward_token_address))))

          (pair

            (pair (nat %reward_token_id)

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

            (pair (nat %stake_token_id)

                  (pair (big_map %stakes address nat) (nat %total_stake)))));

code { CAST (pair

              (or (or unit (or nat unit))

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

              (pair

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

                      (pair address (pair nat address)))

                (pair (pair nat (pair address address))

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

       LAMBDA

         (pair unit

               (pair

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

                       (pair address (pair nat address)))

                 (pair (pair nat (pair address address))

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

         (pair (list operation)

               (pair unit

                     (pair

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

                             (pair address (pair nat address)))

                       (pair (pair nat (pair address address))

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

         { NIL operation ;

           SWAP ;

           CDR ;

           DUP ;

           DUG 2 ;

           CAR ;

           GET 3 ;

           CONTRACT %update unit ;

           IF_NONE { PUSH int 113 ; FAILWITH } {} ;

           PUSH mutez 0 ;

           UNIT ;

           TRANSFER_TOKENS ;

           CONS ;

           SWAP ;

           DUP ;

           DUG 2 ;

           CAR ;

           GET 6 ;

           CONTRACT %balance_of (pair (list (pair address nat))

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

           IF_NONE { PUSH int 63 ; FAILWITH } {} ;

           PUSH mutez 0 ;

           SELF_ADDRESS ;

           CONTRACT %set_reward_balance (list (pair (pair address nat) nat)) ;

           IF_NONE { PUSH int 65 ; FAILWITH } {} ;

           NIL (pair address nat) ;

           DUP 6 ;

           GET 3 ;

           CAR ;

           SELF_ADDRESS ;

           PAIR ;

           CONS ;

           PAIR ;

           TRANSFER_TOKENS ;

           CONS ;

           SWAP ;

           UNIT ;

           DIG 2 ;

           PAIR 3 } ;

       SWAP ;

       LAMBDA

         (pair unit

               (pair

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

                       (pair address (pair nat address)))

                 (pair (pair nat (pair address address))

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

         (pair (list operation)

               (pair unit

                     (pair

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

                             (pair address (pair nat address)))

                       (pair (pair nat (pair address address))

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

         { NIL operation ;

           SWAP ;

           CDR ;

           DUP ;

           GET 7 ;

           SWAP ;

           DUP ;

           DUG 2 ;

           GET 3 ;

           GET 3 ;

           MEM ;

           IF

             { PUSH nat 1000000000000 ;

               SWAP ;

               DUP ;

               CAR ;

               CAR ;

               GET 4 ;

               SWAP ;

               DUP ;

               DUG 3 ;

               GET 3 ;

               GET 3 ;

               GET ;

               IF_NONE { PUSH int 103 ; FAILWITH } {} ;

               DUP 3 ;

               CAR ;

               CAR ;

               GET 3 ;

               SUB ;

               ISNAT ;

               IF_NONE { PUSH int 103 ; FAILWITH } {} ;

               DIG 2 ;

               DUP ;

               GET 7 ;

               SWAP ;

               DUP ;

               DUG 4 ;

               GET 3 ;

               GET 3 ;

               GET ;

               IF_NONE { PUSH int 103 ; FAILWITH } {} ;

               MUL ;

               EDIV ;

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

               DUG 2 ;

               DUP ;

               DUG 3 ;

               CAR ;

               GET 6 ;

               CONTRACT %transfer (list (pair address

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

               IF_NONE { PUSH int 35 ; FAILWITH } {} ;

               PUSH mutez 0 ;

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

               NIL (pair address (pair nat nat)) ;

               DUP 6 ;

               DIG 7 ;

               DUP ;

               GET 3 ;

               CAR ;

               SWAP ;

               DUP ;

               DUG 9 ;

               GET 3 ;

               GET 3 ;

               PAIR 3 ;

               CONS ;

               SELF_ADDRESS ;

               PAIR ;

               CONS ;

               TRANSFER_TOKENS ;

               CONS ;

               DUG 2 ;

               SWAP ;

               DUP ;

               DUG 2 ;

               UNPAIR ;

               UNPAIR ;

               SWAP ;

               UNPAIR ;

               SWAP ;

               CDR ;

               DIG 4 ;

               DIG 5 ;

               CAR ;

               GET 5 ;

               SUB ;

               ISNAT ;

               IF_NONE { PUSH int 106 ; FAILWITH } {} ;

               PAIR ;

               SWAP ;

               PAIR ;

               SWAP ;

               PAIR ;

               PAIR ;

               DUP ;

               UNPAIR ;

               UNPAIR ;

               UNPAIR ;

               SWAP ;

               UNPAIR ;

               SWAP ;

               DUP 6 ;

               CAR ;

               CAR ;

               GET 3 ;

               SOME ;

               DIG 6 ;

               GET 3 ;

               GET 3 ;

               UPDATE ;

               SWAP ;

               PAIR ;

               SWAP ;

               PAIR ;

               PAIR ;

               PAIR }

             {} ;

           UNIT ;

           DIG 2 ;

           PAIR 3 } ;

       SWAP ;

       LAMBDA

         (pair unit

               (pair

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

                       (pair address (pair nat address)))

                 (pair (pair nat (pair address address))

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

         (pair (list operation)

               (pair unit

                     (pair

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

                             (pair address (pair nat address)))

                       (pair (pair nat (pair address address))

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

         { NIL operation ;

           SWAP ;

           CDR ;

           DUP ;

           GET 8 ;

           PUSH nat 0 ;

           COMPARE ;

           LT ;

           IF

             { DUP ;

               UNPAIR ;

               UNPAIR ;

               UNPAIR ;

               SWAP ;

               UNPAIR ;

               DUP 6 ;

               GET 8 ;

               PUSH nat 1000000000000 ;

               DIG 7 ;

               DUP ;

               CAR ;

               GET 5 ;

               SWAP ;

               CAR ;

               CAR ;

               CAR ;

               SUB ;

               ISNAT ;

               IF_NONE { PUSH int 85 ; FAILWITH } {} ;

               MUL ;

               EDIV ;

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

               ADD ;

               PAIR ;

               SWAP ;

               PAIR ;

               PAIR ;

               PAIR ;

               DUP ;

               UNPAIR ;

               UNPAIR ;

               SWAP ;

               UNPAIR ;

               SWAP ;

               CDR ;

               DIG 4 ;

               CAR ;

               CAR ;

               CAR ;

               PAIR ;

               SWAP ;

               PAIR ;

               SWAP ;

               PAIR ;

               PAIR }

             {} ;

           UNIT ;

           DIG 2 ;

           PAIR 3 } ;

       SWAP ;

       LAMBDA

         (pair unit

               (pair

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

                       (pair address (pair nat address)))

                 (pair (pair nat (pair address address))

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

         (pair (list operation)

               (pair unit

                     (pair

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

                             (pair address (pair nat address)))

                       (pair (pair nat (pair address address))

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

         { NIL operation ;

           SWAP ;

           CDR ;

           SELF_ADDRESS ;

           SENDER ;

           COMPARE ;

           EQ ;

           IF {} { PUSH int 400 ; FAILWITH } ;

           UNIT ;

           DIG 2 ;

           PAIR 3 } ;

       SWAP ;

       UNPAIR ;

       IF_LEFT

         { IF_LEFT

             { DROP ;

               SWAP ;

               DROP ;

               SWAP ;

               DROP ;

               SWAP ;

               DROP ;

               UNPAIR ;

               SWAP ;

               UNPAIR ;

               UNPAIR ;

               SWAP ;

               CDR ;

               SENDER ;

               PAIR ;

               SWAP ;

               PAIR ;

               PAIR ;

               SWAP ;

               PAIR ;

               UNIT ;

               PAIR ;

               EXEC ;

               DUP ;

               GET 4 ;

               SWAP ;

               CAR ;

               SELF %internal_claim ;

               PUSH mutez 0 ;

               UNIT ;

               TRANSFER_TOKENS ;

               CONS }

             { IF_LEFT

                 { DIG 2 ;

                   DROP ;

                   DIG 2 ;

                   DROP ;

                   DIG 2 ;

                   DROP ;

                   SWAP ;

                   UNPAIR ;

                   SWAP ;

                   UNPAIR ;

                   UNPAIR ;

                   SWAP ;

                   CDR ;

                   SENDER ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   SWAP ;

                   DUG 2 ;

                   UNIT ;

                   PAIR ;

                   EXEC ;

                   DUP ;

                   GET 4 ;

                   DUG 2 ;

                   CAR ;

                   SELF %internal_deposit ;

                   PUSH mutez 0 ;

                   DIG 3 ;

                   TRANSFER_TOKENS ;

                   CONS }

                 { DUP 3 ;

                   DIG 2 ;

                   UNIT ;

                   PAIR ;

                   EXEC ;

                   DUP ;

                   GET 4 ;

                   DUG 2 ;

                   DUP ;

                   CAR ;

                   DUP 6 ;

                   DIG 4 ;

                   UNIT ;

                   PAIR ;

                   EXEC ;

                   DUP ;

                   GET 4 ;

                   DUG 4 ;

                   DUP ;

                   CAR ;

                   NIL operation ;

                   SWAP ;

                   ITER { CONS } ;

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

                   DUP 8 ;

                   DIG 5 ;

                   UNIT ;

                   PAIR ;

                   EXEC ;

                   DUP ;

                   GET 4 ;

                   DUG 5 ;

                   DUP ;

                   CAR ;

                   NIL operation ;

                   SWAP ;

                   ITER { CONS } ;

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

                   DROP 2 ;

                   SWAP ;

                   DROP ;

                   SWAP ;

                   DROP ;

                   DIG 2 ;

                   DROP ;

                   DIG 2 ;

                   DROP ;

                   DIG 2 ;

                   DROP ;

                   DIG 2 ;

                   DROP } } }

         { IF_LEFT

             { IF_LEFT

                 { DUP 3 ;

                   DIG 2 ;

                   UNIT ;

                   PAIR ;

                   EXEC ;

                   DUP ;

                   GET 4 ;

                   DUG 2 ;

                   DUP ;

                   CAR ;

                   DUP 6 ;

                   DIG 4 ;

                   UNIT ;

                   PAIR ;

                   EXEC ;

                   DUP ;

                   GET 4 ;

                   DUG 4 ;

                   DUP ;

                   CAR ;

                   NIL operation ;

                   SWAP ;

                   ITER { CONS } ;

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

                   DUP 8 ;

                   DIG 5 ;

                   UNIT ;

                   PAIR ;

                   EXEC ;

                   DUP ;

                   GET 4 ;

                   DUG 5 ;

                   DUP ;

                   CAR ;

                   NIL operation ;

                   SWAP ;

                   ITER { CONS } ;

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

                   DROP 2 ;

                   SWAP ;

                   DROP ;

                   DIG 3 ;

                   DROP ;

                   DIG 3 ;

                   DROP ;

                   DIG 3 ;

                   DROP ;

                   DIG 3 ;

                   DROP ;

                   DUP 3 ;

                   GET 3 ;

                   GET 4 ;

                   CONTRACT %transfer (list (pair address

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

                   IF_NONE { PUSH int 35 ; FAILWITH } {} ;

                   PUSH mutez 0 ;

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

                   NIL (pair address (pair nat nat)) ;

                   DUP 6 ;

                   DUP 8 ;

                   GET 5 ;

                   SELF_ADDRESS ;

                   PAIR 3 ;

                   CONS ;

                   DUP 7 ;

                   GET 3 ;

                   GET 3 ;

                   PAIR ;

                   CONS ;

                   TRANSFER_TOKENS ;

                   CONS ;

                   DUP 3 ;

                   UNPAIR ;

                   UNPAIR ;

                   UNPAIR ;

                   SWAP ;

                   UNPAIR ;

                   SWAP ;

                   DUP 8 ;

                   CAR ;

                   CAR ;

                   GET 3 ;

                   SOME ;

                   DIG 8 ;

                   GET 3 ;

                   GET 3 ;

                   UPDATE ;

                   SWAP ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   PAIR ;

                   PAIR ;

                   DUP ;

                   GET 7 ;

                   SWAP ;

                   DUP ;

                   DUG 4 ;

                   GET 3 ;

                   GET 3 ;

                   MEM ;

                   IF

                     { DUP 3 ;

                       DUP ;

                       GET 7 ;

                       DUP ;

                       DIG 5 ;

                       GET 3 ;

                       GET 3 ;

                       DUP ;

                       DUG 2 ;

                       GET ;

                       IF_NONE { PUSH int 161 ; FAILWITH } {} ;

                       DUP 6 ;

                       ADD ;

                       SOME ;

                       SWAP ;

                       UPDATE ;

                       UPDATE 7 ;

                       DUG 2 }

                     { DUP 3 ; DUP ; GET 7 ; DUP 4 ; SOME ; DIG 5 ; GET 3 ; GET 3 ; UPDATE ; UPDATE 7 ; DUG 2 } ;

                   DIG 2 ;

                   DUP ;

                   GET 8 ;

                   DIG 3 ;

                   ADD ;

                   UPDATE 8 ;

                   SWAP }

                 { DUP 3 ;

                   DIG 2 ;

                   UNIT ;

                   PAIR ;

                   EXEC ;

                   DUP ;

                   GET 4 ;

                   DUG 2 ;

                   DUP ;

                   CAR ;

                   DUP 6 ;

                   DIG 4 ;

                   UNIT ;

                   PAIR ;

                   EXEC ;

                   DUP ;

                   GET 4 ;

                   DUG 4 ;

                   DUP ;

                   CAR ;

                   NIL operation ;

                   SWAP ;

                   ITER { CONS } ;

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

                   DUP 8 ;

                   DIG 5 ;

                   UNIT ;

                   PAIR ;

                   EXEC ;

                   DUP ;

                   GET 4 ;

                   DUG 5 ;

                   DUP ;

                   CAR ;

                   NIL operation ;

                   SWAP ;

                   ITER { CONS } ;

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

                   DROP 2 ;

                   SWAP ;

                   DROP ;

                   SWAP ;

                   DROP ;

                   DIG 2 ;

                   DROP ;

                   DIG 2 ;

                   DROP ;

                   DIG 2 ;

                   DROP ;

                   DIG 2 ;

                   DROP ;

                   SWAP ;

                   DUP ;

                   GET 7 ;

                   SWAP ;

                   DUP ;

                   DUG 3 ;

                   GET 3 ;

                   GET 3 ;

                   GET ;

                   IF_NONE { PUSH int 220 ; FAILWITH } {} ;

                   SWAP ;

                   DUP 3 ;

                   GET 3 ;

                   GET 4 ;

                   CONTRACT %transfer (list (pair address

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

                   IF_NONE { PUSH int 35 ; FAILWITH } {} ;

                   PUSH mutez 0 ;

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

                   NIL (pair address (pair nat nat)) ;

                   DUP 6 ;

                   DIG 7 ;

                   DUP ;

                   GET 5 ;

                   SWAP ;

                   DUP ;

                   DUG 9 ;

                   GET 3 ;

                   GET 3 ;

                   PAIR 3 ;

                   CONS ;

                   SELF_ADDRESS ;

                   PAIR ;

                   CONS ;

                   TRANSFER_TOKENS ;

                   CONS ;

                   SWAP ;

                   DUP 3 ;

                   SWAP ;

                   DIG 3 ;

                   GET 8 ;

                   SUB ;

                   ISNAT ;

                   IF_NONE { PUSH int 222 ; FAILWITH } {} ;

                   UPDATE 8 ;

                   DUP ;

                   DUG 2 ;

                   DUP ;

                   GET 7 ;

                   NONE nat ;

                   DIG 4 ;

                   GET 3 ;

                   GET 3 ;

                   UPDATE ;

                   UPDATE 7 ;

                   DUP ;

                   DUG 2 ;

                   UNPAIR ;

                   UNPAIR ;

                   UNPAIR ;

                   SWAP ;

                   UNPAIR ;

                   SWAP ;

                   NONE nat ;

                   DIG 7 ;

                   GET 3 ;

                   GET 3 ;

                   UPDATE ;

                   SWAP ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   PAIR ;

                   PAIR ;

                   SWAP } }

             { IF_LEFT

                 { DUP ;

                   IF_CONS

                     { SWAP ;

                       DROP ;

                       SWAP ;

                       DROP ;

                       DIG 2 ;

                       DROP ;

                       DIG 2 ;

                       DROP ;

                       DIG 2 ;

                       DROP ;

                       DIG 2 ;

                       DROP ;

                       SWAP ;

                       UNPAIR ;

                       UNPAIR ;

                       CDR ;

                       DIG 3 ;

                       CDR ;

                       PAIR ;

                       PAIR ;

                       PAIR }

                     { DROP ; SWAP ; DROP ; SWAP ; DROP ; SWAP ; DROP ; SWAP ; DROP } ;

                   NIL operation }

                 { DROP ;

                   SWAP ;

                   DROP ;

                   SWAP ;

                   DROP ;

                   SWAP ;

                   DROP ;

                   UNPAIR ;

                   SWAP ;

                   UNPAIR ;

                   UNPAIR ;

                   SWAP ;

                   CDR ;

                   SENDER ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   UNIT ;

                   PAIR ;

                   EXEC ;

                   DUP ;

                   GET 4 ;

                   SWAP ;

                   CAR ;

                   SELF %internal_withdraw ;

                   PUSH mutez 0 ;

                   UNIT ;

                   TRANSFER_TOKENS ;

                   CONS } } } ;

       NIL operation ;

       SWAP ;

       ITER { CONS } ;

       PAIR }