parameter (or

            (or (or (pair %AddReward (nat %blocks) (nat %reward)) (unit %GetReward))

                (or

                  (pair %RecoverExcessToken (pair (address %address) (nat %id))

                                            (pair (address %token)

                                                  (pair (nat %type) (nat %value))))

                  (unit %WithdrawFee)))

            (or (or (address %changeAdmin) (unit %changeState))

                (or

                  (pair %changeUnstakeFee (pair (nat %blocksPerCycle) (nat %cycles))

                                          (pair (nat %defaultFee) (nat %fee)))

                  (or (nat %stake) (pair %unstake (nat %Amount) (nat %MapKey))))));

storage (pair

          (pair

            (pair (address %admin)

                  (pair

                    (big_map %balances address

                                       (pair

                                         (pair

                                           (map %InvestMap nat

                                                           (pair (nat %amount)

                                                                 (nat %level)))

                                           (nat %balance))

                                         (pair (nat %counter)

                                               (pair (nat %rewards)

                                                     (nat %userRewardPerTokenPaid)))))

                    (nat %blocksPerCycle)))

            (pair (pair (nat %defaultUnstakeFee) (bool %faTwoToken))

                  (pair (nat %lastUpdateTime) (bool %paused))))

          (pair

            (pair (pair (nat %periodFinish) (nat %rewardPerTokenStored))

                  (pair (nat %rewardRate) (address %rewardToken)))

            (pair (pair (address %stakeToken) (nat %totalFee))

                  (pair (nat %totalSupply) (map %unstakeFee nat nat)))));

code { LAMBDA

         (pair address

               (pair

                 (pair

                   (pair address

                         (pair

                           (big_map address

                                    (pair (pair (map nat (pair nat nat)) nat)

                                          (pair nat (pair nat nat))))

                           nat))

                   (pair (pair nat bool) (pair nat bool)))

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

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

         (pair (list operation)

               (pair unit

                     (pair

                       (pair

                         (pair address

                               (pair

                                 (big_map address

                                          (pair (pair (map nat (pair nat nat)) nat)

                                                (pair nat (pair nat nat))))

                                 nat))

                         (pair (pair nat bool) (pair nat bool)))

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

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

         { NIL operation ;

           SWAP ;

           DUP ;

           DUG 2 ;

           CDR ;

           DUP ;

           GET 3 ;

           CAR ;

           CAR ;

           LEVEL ;

           COMPARE ;

           GT ;

           IF { DUP ; GET 3 ; CAR ; CAR } { LEVEL } ;

           PUSH nat 0 ;

           DUP 3 ;

           GET 7 ;

           COMPARE ;

           NEQ ;

           IF

             { PUSH nat 0 ;

               DUP 3 ;

               CAR ;

               GET 5 ;

               DUP 3 ;

               SUB ;

               ISNAT ;

               IF_NONE { PUSH int 58 ; FAILWITH } {} ;

               ADD ;

               DUP 3 ;

               GET 3 ;

               GET 3 ;

               PUSH nat 10000000000 ;

               DIG 2 ;

               MUL ;

               MUL ;

               DUP 3 ;

               GET 7 ;

               SWAP ;

               EDIV ;

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

               DIG 2 ;

               UNPAIR ;

               SWAP ;

               UNPAIR ;

               UNPAIR ;

               UNPAIR ;

               SWAP ;

               DIG 5 ;

               ADD ;

               SWAP ;

               PAIR ;

               PAIR ;

               PAIR ;

               SWAP ;

               PAIR ;

               SWAP }

             {} ;

           SWAP ;

           UNPAIR ;

           UNPAIR ;

           SWAP ;

           UNPAIR ;

           SWAP ;

           CDR ;

           DIG 4 ;

           PAIR ;

           SWAP ;

           PAIR ;

           SWAP ;

           PAIR ;

           PAIR ;

           SELF_ADDRESS ;

           DUP 4 ;

           CAR ;

           COMPARE ;

           NEQ ;

           IF

             { DUP ;

               UNPAIR ;

               UNPAIR ;

               UNPAIR ;

               SWAP ;

               UNPAIR ;

               DUP ;

               DUP 9 ;

               CAR ;

               DUP ;

               DUG 2 ;

               GET ;

               IF_NONE { PUSH int 71 ; FAILWITH } {} ;

               DUP ;

               GET 5 ;

               PUSH nat 10000000000 ;

               DUP 10 ;

               CAR ;

               CAR ;

               GET 3 ;

               DUP 13 ;

               CAR ;

               GET ;

               IF_NONE { PUSH int 71 ; FAILWITH } {} ;

               GET 6 ;

               DUP 11 ;

               GET 3 ;

               CAR ;

               CDR ;

               SUB ;

               ISNAT ;

               IF_NONE { PUSH int 71 ; FAILWITH } {} ;

               DIG 10 ;

               CAR ;

               CAR ;

               GET 3 ;

               DUP 13 ;

               CAR ;

               GET ;

               IF_NONE { PUSH int 71 ; FAILWITH } {} ;

               CAR ;

               CDR ;

               MUL ;

               EDIV ;

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

               ADD ;

               UPDATE 5 ;

               SOME ;

               SWAP ;

               UPDATE ;

               PAIR ;

               SWAP ;

               PAIR ;

               PAIR ;

               PAIR ;

               DUP ;

               UNPAIR ;

               UNPAIR ;

               UNPAIR ;

               SWAP ;

               UNPAIR ;

               DUP ;

               DIG 8 ;

               CAR ;

               DUP ;

               DUG 2 ;

               GET ;

               IF_NONE { PUSH int 73 ; FAILWITH } {} ;

               DIG 7 ;

               GET 3 ;

               CAR ;

               CDR ;

               UPDATE 6 ;

               SOME ;

               SWAP ;

               UPDATE ;

               PAIR ;

               SWAP ;

               PAIR ;

               PAIR ;

               PAIR }

             { DIG 2 ; DROP } ;

           UNIT ;

           DIG 2 ;

           PAIR 3 } ;

       SWAP ;

       UNPAIR ;

       IF_LEFT

         { IF_LEFT

             { IF_LEFT

                 { SWAP ;

                   DUP ;

                   DUG 2 ;

                   CAR ;

                   CAR ;

                   CAR ;

                   SENDER ;

                   COMPARE ;

                   EQ ;

                   IF {} { PUSH string "Invalid Account" ; FAILWITH } ;

                   DUG 2 ;

                   SELF_ADDRESS ;

                   PAIR ;

                   EXEC ;

                   DUP ;

                   GET 4 ;

                   DUG 2 ;

                   CAR ;

                   DUP 3 ;

                   GET 3 ;

                   CAR ;

                   CAR ;

                   LEVEL ;

                   COMPARE ;

                   GE ;

                   IF

                     { DIG 2 ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       UNPAIR ;

                       SWAP ;

                       CDR ;

                       DIG 5 ;

                       DUP ;

                       CAR ;

                       SWAP ;

                       DUP ;

                       DUG 7 ;

                       CDR ;

                       EDIV ;

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

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       DUG 2 }

                     { LEVEL ;

                       DUP 4 ;

                       GET 3 ;

                       CAR ;

                       CAR ;

                       SUB ;

                       ISNAT ;

                       IF_NONE { PUSH int 229 ; FAILWITH } {} ;

                       DUP 4 ;

                       GET 3 ;

                       GET 3 ;

                       MUL ;

                       DIG 3 ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       UNPAIR ;

                       SWAP ;

                       CDR ;

                       DIG 6 ;

                       DUP ;

                       CAR ;

                       SWAP ;

                       DUP ;

                       DUG 8 ;

                       CDR ;

                       DIG 6 ;

                       ADD ;

                       EDIV ;

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

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       DUG 2 } ;

                   DIG 2 ;

                   UNPAIR ;

                   UNPAIR ;

                   SWAP ;

                   UNPAIR ;

                   SWAP ;

                   CDR ;

                   LEVEL ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   SWAP ;

                   UNPAIR ;

                   UNPAIR ;

                   CDR ;

                   DIG 5 ;

                   CAR ;

                   LEVEL ;

                   ADD ;

                   PAIR ;

                   PAIR ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   SWAP }

                 { SWAP ;

                   DUP ;

                   DUG 2 ;

                   CAR ;

                   CAR ;

                   GET 3 ;

                   SENDER ;

                   MEM ;

                   IF {} { PUSH string "User has not Staked" ; FAILWITH } ;

                   DUP 3 ;

                   DIG 2 ;

                   SENDER ;

                   PAIR ;

                   EXEC ;

                   DUP ;

                   GET 4 ;

                   DUG 2 ;

                   DUP ;

                   CAR ;

                   DUP 4 ;

                   GET 3 ;

                   CAR ;

                   CAR ;

                   LEVEL ;

                   COMPARE ;

                   GT ;

                   IF { DUP 4 ; GET 3 ; CAR ; CAR } { LEVEL } ;

                   DUP 5 ;

                   GET 3 ;

                   CAR ;

                   CDR ;

                   PUSH nat 0 ;

                   DUP 7 ;

                   GET 7 ;

                   COMPARE ;

                   NEQ ;

                   IF

                     { DROP ;

                       DUP 5 ;

                       CAR ;

                       GET 5 ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       SUB ;

                       ISNAT ;

                       IF_NONE { PUSH int 97 ; FAILWITH } {} ;

                       DUP 6 ;

                       GET 3 ;

                       CAR ;

                       CDR ;

                       PUSH nat 10000000000 ;

                       DUP ;

                       DUP 9 ;

                       GET 3 ;

                       GET 3 ;

                       DIG 4 ;

                       MUL ;

                       MUL ;

                       EDIV ;

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

                       ADD }

                     {} ;

                   DUP 6 ;

                   CAR ;

                   CAR ;

                   GET 3 ;

                   SENDER ;

                   GET ;

                   IF_NONE { PUSH int 103 ; FAILWITH } {} ;

                   CAR ;

                   CDR ;

                   DUP 7 ;

                   CAR ;

                   CAR ;

                   GET 3 ;

                   SENDER ;

                   GET ;

                   IF_NONE { PUSH int 105 ; FAILWITH } {} ;

                   GET 6 ;

                   DUP 3 ;

                   SUB ;

                   ISNAT ;

                   IF_NONE { PUSH int 105 ; FAILWITH } {} ;

                   MUL ;

                   DUP 7 ;

                   CAR ;

                   CAR ;

                   GET 3 ;

                   SENDER ;

                   GET ;

                   IF_NONE { PUSH int 107 ; FAILWITH } {} ;

                   GET 5 ;

                   PUSH nat 10000000000 ;

                   DIG 2 ;

                   EDIV ;

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

                   ADD ;

                   DUP ;

                   PUSH nat 0 ;

                   COMPARE ;

                   LT ;

                   IF

                     { SWAP ;

                       DROP ;

                       SWAP ;

                       DROP ;

                       DIG 2 ;

                       DROP ;

                       DIG 2 ;

                       DROP ;

                       DIG 3 ;

                       DROP ;

                       DIG 2 ;

                       UNPAIR ;

                       UNPAIR ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       DUP ;

                       SENDER ;

                       DUP ;

                       DUG 2 ;

                       GET ;

                       IF_NONE { PUSH int 111 ; FAILWITH } {} ;

                       PUSH nat 0 ;

                       UPDATE 5 ;

                       SOME ;

                       SWAP ;

                       UPDATE ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       PAIR ;

                       PAIR ;

                       DUP ;

                       DUG 3 ;

                       CAR ;

                       GET 3 ;

                       CDR ;

                       IF

                         { SWAP ;

                           DUP 3 ;

                           GET 3 ;

                           GET 4 ;

                           CONTRACT %transfer (list (pair address

                                                         (list (pair address

                                                                    (pair nat nat))))) ;

                           IF_NONE { PUSH int 322 ; FAILWITH } {} ;

                           PUSH mutez 0 ;

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

                           NIL (pair address (pair nat nat)) ;

                           DIG 5 ;

                           PUSH nat 0 ;

                           SENDER ;

                           PAIR 3 ;

                           CONS ;

                           SELF_ADDRESS ;

                           PAIR ;

                           CONS ;

                           TRANSFER_TOKENS ;

                           CONS }

                         { SWAP ;

                           DUP 3 ;

                           GET 3 ;

                           GET 4 ;

                           CONTRACT %transfer (pair address (pair address nat)) ;

                           IF_NONE { PUSH int 338 ; FAILWITH } {} ;

                           PUSH mutez 0 ;

                           DIG 3 ;

                           SENDER ;

                           SELF_ADDRESS ;

                           PAIR 3 ;

                           TRANSFER_TOKENS ;

                           CONS } }

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

             { IF_LEFT

                 { DIG 2 ;

                   DROP ;

                   SWAP ;

                   DUP ;

                   DUG 2 ;

                   CAR ;

                   CAR ;

                   CAR ;

                   SENDER ;

                   COMPARE ;

                   EQ ;

                   IF {} { PUSH string "Invalid Account" ; FAILWITH } ;

                   DUP ;

                   GET 5 ;

                   PUSH nat 1 ;

                   COMPARE ;

                   EQ ;

                   IF

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       GET 5 ;

                       CAR ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CAR ;

                       COMPARE ;

                       NEQ ;

                       IF

                         { PUSH bool True }

                         { DUP ; CAR ; CDR ; PUSH nat 0 ; COMPARE ; NEQ } ;

                       IF

                         {}

                         { PUSH string "Admin trying to recover the staked tokens" ;

                           FAILWITH } ;

                       DUP ;

                       GET 3 ;

                       CONTRACT %transfer (list (pair address

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

                       IF_NONE { PUSH int 322 ; FAILWITH } {} ;

                       NIL operation ;

                       SWAP ;

                       PUSH mutez 0 ;

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

                       NIL (pair address (pair nat nat)) ;

                       DIG 5 ;

                       DUP ;

                       GET 6 ;

                       SWAP ;

                       DUP ;

                       CAR ;

                       CDR ;

                       SWAP ;

                       CAR ;

                       CAR ;

                       PAIR 3 ;

                       CONS ;

                       SELF_ADDRESS ;

                       PAIR ;

                       CONS ;

                       TRANSFER_TOKENS ;

                       CONS }

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       GET 5 ;

                       CAR ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CAR ;

                       COMPARE ;

                       NEQ ;

                       IF

                         {}

                         { PUSH string "Admin trying to recover the staked tokens" ;

                           FAILWITH } ;

                       DUP ;

                       GET 3 ;

                       CONTRACT %transfer (pair address (pair address nat)) ;

                       IF_NONE { PUSH int 338 ; FAILWITH } {} ;

                       NIL operation ;

                       SWAP ;

                       PUSH mutez 0 ;

                       DIG 3 ;

                       DUP ;

                       GET 6 ;

                       SWAP ;

                       CAR ;

                       CAR ;

                       SELF_ADDRESS ;

                       PAIR 3 ;

                       TRANSFER_TOKENS ;

                       CONS } }

                 { DROP ;

                   SWAP ;

                   DROP ;

                   DUP ;

                   GET 5 ;

                   CDR ;

                   PUSH nat 0 ;

                   COMPARE ;

                   LT ;

                   IF {} { PUSH string "Fee Should be Greater than 0" ; FAILWITH } ;

                   DUP ;

                   CAR ;

                   CAR ;

                   CAR ;

                   SENDER ;

                   COMPARE ;

                   EQ ;

                   IF {} { PUSH string "Invalid User" ; FAILWITH } ;

                   DUP ;

                   GET 5 ;

                   CDR ;

                   SWAP ;

                   UNPAIR ;

                   SWAP ;

                   UNPAIR ;

                   SWAP ;

                   UNPAIR ;

                   CAR ;

                   PUSH nat 0 ;

                   SWAP ;

                   PAIR ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   SWAP ;

                   NIL operation ;

                   DUP 3 ;

                   GET 5 ;

                   CAR ;

                   CONTRACT %transfer (pair address (pair address nat)) ;

                   IF_NONE { PUSH int 338 ; FAILWITH } {} ;

                   PUSH mutez 0 ;

                   DIG 3 ;

                   SENDER ;

                   SELF_ADDRESS ;

                   PAIR 3 ;

                   TRANSFER_TOKENS ;

                   CONS } } }

         { IF_LEFT

             { DIG 2 ;

               DROP ;

               IF_LEFT

                 { SWAP ;

                   DUP ;

                   DUG 2 ;

                   CAR ;

                   CAR ;

                   CAR ;

                   SENDER ;

                   COMPARE ;

                   EQ ;

                   IF {} { PUSH string "Invalid User" ; FAILWITH } ;

                   SWAP ;

                   UNPAIR ;

                   UNPAIR ;

                   CDR ;

                   DIG 3 ;

                   PAIR ;

                   PAIR ;

                   PAIR }

                 { DROP ;

                   DUP ;

                   CAR ;

                   CAR ;

                   CAR ;

                   SENDER ;

                   COMPARE ;

                   EQ ;

                   IF {} { PUSH string "Invalid User" ; FAILWITH } ;

                   DUP ;

                   UNPAIR ;

                   UNPAIR ;

                   SWAP ;

                   UNPAIR ;

                   SWAP ;

                   CAR ;

                   DIG 4 ;

                   CAR ;

                   GET 6 ;

                   NOT ;

                   SWAP ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   PAIR } ;

               NIL operation }

             { IF_LEFT

                 { DIG 2 ;

                   DROP ;

                   SWAP ;

                   DUP ;

                   DUG 2 ;

                   CAR ;

                   CAR ;

                   CAR ;

                   SENDER ;

                   COMPARE ;

                   EQ ;

                   IF {} { PUSH string "Invalid User" ; FAILWITH } ;

                   SWAP ;

                   DUP ;

                   GET 8 ;

                   DUP 3 ;

                   GET 4 ;

                   SOME ;

                   DUP 4 ;

                   CAR ;

                   CDR ;

                   UPDATE ;

                   UPDATE 8 ;

                   UNPAIR ;

                   UNPAIR ;

                   UNPAIR ;

                   SWAP ;

                   CAR ;

                   DUP 5 ;

                   CAR ;

                   CAR ;

                   SWAP ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   SWAP ;

                   UNPAIR ;

                   CDR ;

                   DIG 4 ;

                   GET 3 ;

                   PAIR ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   PAIR ;

                   NIL operation }

                 { IF_LEFT

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       GET 6 ;

                       IF

                         { PUSH string "Contract is not accepting New Staking Orders" ;

                           FAILWITH }

                         {} ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       GET 3 ;

                       CAR ;

                       CAR ;

                       LEVEL ;

                       COMPARE ;

                       LE ;

                       IF

                         {}

                         { PUSH string "Users can't stake after period finish" ;

                           FAILWITH } ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CAR ;

                       GET 3 ;

                       SENDER ;

                       MEM ;

                       IF

                         {}

                         { SWAP ;

                           UNPAIR ;

                           UNPAIR ;

                           UNPAIR ;

                           SWAP ;

                           UNPAIR ;

                           PUSH (option (pair (pair (map nat (pair nat nat)) nat)

                                          (pair nat (pair nat nat)))) (Some (Pair (Pair {} 0) (Pair 0 (Pair 0 0)))) ;

                           SENDER ;

                           UPDATE ;

                           PAIR ;

                           SWAP ;

                           PAIR ;

                           PAIR ;

                           PAIR ;

                           SWAP } ;

                       DUG 2 ;

                       SENDER ;

                       PAIR ;

                       EXEC ;

                       DUP ;

                       GET 4 ;

                       DUG 2 ;

                       CAR ;

                       PUSH nat 0 ;

                       DUP 3 ;

                       COMPARE ;

                       GT ;

                       IF

                         {}

                         { PUSH string "Cannot Stake Amount Less than 1" ; FAILWITH } ;

                       PUSH nat 0 ;

                       PUSH nat 10000000000000000000 ;

                       DUP 4 ;

                       EDIV ;

                       IF_NONE { PUSH int 136 ; FAILWITH } { CDR } ;