parameter (or

            (or (or (unit %claim_all) (nat %increase_reward))

                (or (unit %initialize) (address %set_admin)))

            (or (nat %stake) (nat %unstake)));

storage (pair

          (pair

            (pair (pair (address %admin) (timestamp %creation_time))

                  (pair (list %farm_points nat) (bool %initialized)))

            (pair

              (pair (option %input_fa2_token_id_opt nat) (address %input_token_address))

              (pair (nat %rate) (list %reward_at_week nat))))

          (pair

            (pair

              (pair (option %reward_fa2_token_id_opt nat)

                    (address %reward_reserve_address))

              (pair (address %reward_token_address) (nat %total_reward)))

            (pair (pair (nat %total_weeks) (big_map %user_points address (list nat)))

                  (pair (big_map %user_stakes address nat) (nat %week_duration)))));

code { { { DUP ; CAR ; DIP { CDR } } } ;

       IF_LEFT

         { IF_LEFT

             { IF_LEFT

                 { DROP ;

                   PUSH string "The contract is not initialized" ;

                   PUSH bool True ;

                   { DIP 2 { DUP } ; DIG 3 } ;

                   CAR ;

                   CAR ;

                   CDR ;

                   CDR ;

                   COMPARE ;

                   EQ ;

                   IF { DROP } { FAILWITH } ;

                   SENDER ;

                   SWAP ;

                   DUP ;

                   DUG 2 ;

                   CAR ;

                   CAR ;

                   CAR ;

                   CDR ;

                   NOW ;

                   SUB ;

                   ABS ;

                   PUSH nat 1 ;

                   { DIP 3 { DUP } ; DIG 4 } ;

                   CDR ;

                   CDR ;

                   CDR ;

                   CDR ;

                   DIG 2 ;

                   EDIV ;

                   IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ;

                   CAR ;

                   ADD ;

                   PUSH string "You cannot claim any reward before the first farm week as passed" ;

                   PUSH nat 1 ;

                   { DIP 2 { DUP } ; DIG 3 } ;

                   COMPARE ;

                   GT ;

                   IF { DROP } { FAILWITH } ;

                   PUSH string "You must not send Tezos to the smart contract" ;

                   PUSH mutez 0 ;

                   AMOUNT ;

                   COMPARE ;

                   EQ ;

                   IF { DROP } { FAILWITH } ;

                   PUSH nat 1 ;

                   SWAP ;

                   SUB ;

                   ABS ;

                   { DIP 2 { DUP } ; DIG 3 } ;

                   CDR ;

                   CDR ;

                   CAR ;

                   CDR ;

                   { DIP 2 { DUP } ; DIG 3 } ;

                   GET ;

                   IF_NONE

                     { DROP 2 ; NIL operation ; PAIR }

                     { { DIP 3 { DUP } ; DIG 4 } ;

                       CAR ;

                       CDR ;

                       CDR ;

                       CDR ;

                       { DIP 4 { DUP } ; DIG 5 } ;

                       CAR ;

                       CAR ;

                       CDR ;

                       CAR ;

                       { DIP 2 { DUP } ; DIG 3 } ;

                       PAIR ;

                       { DIP 3 { DUP } ; DIG 4 } ;

                       PUSH nat 0 ;

                       PAIR ;

                       PAIR ;

                       PAIR ;

                       LEFT nat ;

                       LOOP_LEFT { { { DUP ; CAR ; DIP { CDR } } } ;

                                   { { DUP ; CAR ; DIP { CDR } } } ;

                                   { { DUP ; CAR ; DIP { CDR } } } ;

                                   DIG 2 ;

                                   { { DUP ; CAR ; DIP { CDR } } } ;

                                   DIG 4 ;

                                   DUG 2 ;

                                   IF_CONS

                                     { DIG 2 ;

                                       IF_CONS

                                         { DIG 4 ;

                                           IF_CONS

                                             { PUSH nat 0 ;

                                               { DIP 8 { DUP } ; DIG 9 } ;

                                               COMPARE ;

                                               GT ;

                                               IF

                                                 { PUSH nat 0 ;

                                                   { DIP 3 { DUP } ; DIG 4 } ;

                                                   COMPARE ;

                                                   EQ ;

                                                   IF

                                                     { DIG 2 ;

                                                       DIG 4 ;

                                                       DROP 3 ;

                                                       SWAP ;

                                                       DIG 2 ;

                                                       PAIR ;

                                                       PUSH nat 1 ;

                                                       DIG 4 ;

                                                       SUB ;

                                                       ABS ;

                                                       DIG 3 ;

                                                       PAIR ;

                                                       PAIR ;

                                                       PAIR ;

                                                       LEFT nat }

                                                     { DIG 2 ;

                                                       SWAP ;

                                                       DIG 4 ;

                                                       MUL ;

                                                       EDIV ;

                                                       IF_NONE

                                                         { PUSH string "DIV by 0" ;

                                                           FAILWITH }

                                                         {} ;

                                                       CAR ;

                                                       DIG 4 ;

                                                       ADD ;

                                                       SWAP ;

                                                       DIG 2 ;

                                                       DIG 3 ;

                                                       PAIR ;

                                                       PUSH nat 1 ;

                                                       DIG 4 ;

                                                       SUB ;

                                                       ABS ;

                                                       DIG 3 ;

                                                       PAIR ;

                                                       PAIR ;

                                                       PAIR ;

                                                       LEFT nat } }

                                                 { SWAP ;

                                                   DIG 2 ;

                                                   DIG 3 ;

                                                   DIG 4 ;

                                                   DIG 5 ;

                                                   DIG 7 ;

                                                   DROP 7 ;

                                                   RIGHT (pair

                                                           (pair (pair nat nat)

                                                                 (pair (list nat)

                                                                       (list nat)))

                                                           (list nat)) } }

                                             { DROP 6 ;

                                               PUSH string "size don't match" ;

                                               FAILWITH } }

                                         { DROP 5 ;

                                           PUSH string "size don't match" ;

                                           FAILWITH } }

                                     { DIG 3 ;

                                       DROP ;

                                       IF_CONS

                                         { DROP 4 ;

                                           PUSH string "size don't match" ;

                                           FAILWITH }

                                         { IF_CONS

                                             { DROP 3 ;

                                               PUSH string "size don't match" ;

                                               FAILWITH }

                                             { RIGHT (pair

                                                       (pair (pair nat nat)

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

                                                       (list nat)) } } } } ;

                       { DIP 4 { DUP } ; DIG 5 } ;

                       CDR ;

                       CAR ;

                       CDR ;

                       CAR ;

                       { DIP 5 { DUP } ; DIG 6 } ;

                       CDR ;

                       CAR ;

                       CAR ;

                       CDR ;

                       { DIP 6 { DUP } ; DIG 7 } ;

                       CDR ;

                       CAR ;

                       CAR ;

                       CAR ;

                       IF_NONE

                         { SWAP ;

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

                           IF_NONE

                             { PUSH string "Cannot connect to the reward token entrypoint" ;

                               FAILWITH }

                             {} ;

                           PUSH mutez 0 ;

                           { DIP 3 { DUP } ; DIG 4 } ;

                           { DIP 7 { DUP } ; DIG 8 } ;

                           PAIR ;

                           DIG 3 ;

                           PAIR ;

                           TRANSFER_TOKENS }

                         { DIG 2 ;

                           CONTRACT %transfer (list (pair address

                                                         (list (pair address

                                                                    (pair nat nat))))) ;

                           IF_NONE

                             { PUSH string "Cannot connect to the reward FA2 token entrypoint" ;

                               FAILWITH }

                             {} ;

                           PUSH mutez 0 ;

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

                           NIL (pair address (pair nat nat)) ;

                           { DIP 6 { DUP } ; DIG 7 } ;

                           DIG 5 ;

                           PAIR ;

                           { DIP 9 { DUP } ; DIG 10 } ;

                           PAIR ;

                           CONS ;

                           DIG 4 ;

                           PAIR ;

                           CONS ;

                           TRANSFER_TOKENS } ;

                       PUSH nat 0 ;

                       DIG 2 ;

                       COMPARE ;

                       EQ ;

                       IF

                         { DROP 4 ; NIL operation ; PAIR }

                         { NIL nat ;

                           DIG 2 ;

                           DIG 3 ;

                           NIL nat ;

                           PAIR ;

                           PAIR ;

                           LEFT (list nat) ;

                           LOOP_LEFT { { { DUP ; CAR ; DIP { CDR } } } ;

                                       { { DUP ; CAR ; DIP { CDR } } } ;

                                       DIG 2 ;

                                       IF_CONS

                                         { PUSH nat 0 ;

                                           { DIP 4 { DUP } ; DIG 5 } ;

                                           COMPARE ;

                                           GT ;

                                           IF

                                             { DROP ;

                                               PUSH nat 1 ;

                                               DIG 3 ;

                                               SUB ;

                                               ABS ;

                                               DIG 2 ;

                                               PUSH nat 0 ;

                                               CONS ;

                                               PAIR ;

                                               PAIR ;

                                               LEFT (list nat) }

                                             { SWAP ; DUG 3 ; CONS ; PAIR ; PAIR ; LEFT (list nat) } }

                                         { SWAP ;

                                           DROP ;

                                           RIGHT (pair (pair (list nat) nat) (list nat)) } } ;

                           PAIR ;

                           LEFT (list nat) ;

                           LOOP_LEFT { { { DUP ; CAR ; DIP { CDR } } } ;

                                       IF_CONS

                                         { DIG 2 ; SWAP ; CONS ; SWAP ; PAIR ; LEFT (list nat) }

                                         { RIGHT (pair (list nat) (list nat)) } } ;

                           { DIP 3 { DUP } ; DIG 4 } ;

                           CDR ;

                           CDR ;

                           CDR ;

                           { DIP 4 { DUP } ; DIG 5 } ;

                           CDR ;

                           CDR ;

                           CAR ;

                           CDR ;

                           DIG 2 ;

                           SOME ;

                           DIG 4 ;

                           UPDATE ;

                           { DIP 3 { DUP } ; DIG 4 } ;

                           CDR ;

                           CDR ;

                           CAR ;

                           CAR ;

                           PAIR ;

                           PAIR ;

                           { DIP 2 { DUP } ; DIG 3 } ;

                           CDR ;

                           CAR ;

                           PAIR ;

                           DIG 2 ;

                           CAR ;

                           PAIR ;

                           NIL operation ;

                           DIG 2 ;

                           CONS ;

                           PAIR } } }

                 { SWAP ;

                   DUP ;

                   DUG 2 ;

                   CDR ;

                   CDR ;

                   CAR ;

                   CAR ;

                   NOW ;

                   { DIP 3 { DUP } ; DIG 4 } ;

                   CAR ;

                   CAR ;

                   CAR ;

                   CDR ;

                   { DIP 4 { DUP } ; DIG 5 } ;

                   CAR ;

                   CAR ;

                   CAR ;

                   CDR ;

                   NOW ;

                   SUB ;

                   ABS ;

                   PUSH nat 1 ;

                   { DIP 6 { DUP } ; DIG 7 } ;

                   CDR ;

                   CDR ;

                   CDR ;

                   CDR ;

                   DIG 2 ;

                   EDIV ;

                   IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ;

                   CAR ;

                   ADD ;

                   PUSH string "The contract is not initialized" ;

                   PUSH bool True ;

                   { DIP 7 { DUP } ; DIG 8 } ;

                   CAR ;

                   CAR ;

                   CDR ;

                   CDR ;

                   COMPARE ;

                   EQ ;

                   IF { DROP } { FAILWITH } ;

                   PUSH string "Only the contract admin can change the contract administrator or increase reward" ;

                   { DIP 6 { DUP } ; DIG 7 } ;

                   CAR ;

                   CAR ;

                   CAR ;

                   CAR ;

                   SENDER ;

                   COMPARE ;

                   EQ ;

                   IF { DROP } { FAILWITH } ;

                   PUSH string "You must not send Tezos to the smart contract" ;

                   PUSH mutez 0 ;

                   AMOUNT ;

                   COMPARE ;

                   EQ ;

                   IF { DROP } { FAILWITH } ;

                   PUSH string "There are no more weeks left for staking in the farm" ;

                   { DIP 6 { DUP } ; DIG 7 } ;

                   CDR ;

                   CDR ;

                   CDR ;

                   CDR ;

                   { DIP 5 { DUP } ; DIG 6 } ;

                   MUL ;

                   INT ;

                   { DIP 3 { DUP } ; DIG 4 } ;

                   ADD ;

                   { DIP 4 { DUP } ; DIG 5 } ;

                   COMPARE ;

                   LT ;

                   IF { DROP } { FAILWITH } ;

                   PUSH string "The increase amount must be greater than zero" ;

                   PUSH nat 0 ;

                   { DIP 6 { DUP } ; DIG 7 } ;

                   COMPARE ;

                   GT ;

                   IF { DROP } { FAILWITH } ;

                   PUSH nat 1 ;

                   SWAP ;

                   DUP ;

                   DUG 2 ;

                   DIG 5 ;

                   SUB ;

                   ABS ;

                   ADD ;

                   { DIP 5 { DUP } ; DIG 6 } ;

                   CAR ;

                   CDR ;

                   CDR ;

                   CAR ;

                   NIL nat ;

                   { DIP 2 { DUP } ; DIG 3 } ;

                   PAIR ;

                   LEFT (list nat) ;

                   LOOP_LEFT { { { DUP ; CAR ; DIP { CDR } } } ;

                               PUSH nat 0 ;

                               SWAP ;

                               DUP ;

                               DUG 2 ;

                               COMPARE ;

                               EQ ;

                               IF

                                 { DROP ; RIGHT (pair nat (list nat)) }

                                 { SWAP ;

                                   PUSH nat 1 ;

                                   { DIP 2 { DUP } ; DIG 3 } ;

                                   SUB ;

                                   ABS ;

                                   { DIP 3 { DUP } ; DIG 4 } ;

                                   PUSH nat 1 ;

                                   PAIR ;

                                   PAIR ;

                                   LEFT nat ;

                                   LOOP_LEFT { { { DUP ; CAR ; DIP { CDR } } } ;

                                               { { DUP ; CAR ; DIP { CDR } } } ;

                                               PUSH nat 0 ;

                                               { DIP 3 { DUP } ; DIG 4 } ;

                                               COMPARE ;

                                               EQ ;

                                               IF

                                                 { SWAP ;

                                                   DIG 2 ;

                                                   DROP 2 ;

                                                   RIGHT (pair (pair nat nat) nat) }

                                                 { PUSH nat 1 ;

                                                   DIG 3 ;

                                                   SUB ;

                                                   ABS ;

                                                   DIG 2 ;

                                                   DUP ;

                                                   DIG 3 ;

                                                   MUL ;

                                                   PAIR ;

                                                   PAIR ;

                                                   LEFT nat } } ;

                                   PUSH nat 1 ;

                                   { DIP 3 { DUP } ; DIG 4 } ;

                                   SUB ;

                                   ABS ;

                                   PUSH nat 10000 ;

                                   PUSH nat 1 ;

                                   PAIR ;

                                   PAIR ;

                                   LEFT nat ;

                                   LOOP_LEFT { { { DUP ; CAR ; DIP { CDR } } } ;

                                               { { DUP ; CAR ; DIP { CDR } } } ;

                                               PUSH nat 0 ;

                                               { DIP 3 { DUP } ; DIG 4 } ;

                                               COMPARE ;

                                               EQ ;

                                               IF

                                                 { SWAP ;

                                                   DIG 2 ;

                                                   DROP 2 ;

                                                   RIGHT (pair (pair nat nat) nat) }

                                                 { PUSH nat 1 ;

                                                   DIG 3 ;

                                                   SUB ;

                                                   ABS ;

                                                   DIG 2 ;

                                                   DUP ;

                                                   DIG 3 ;

                                                   MUL ;

                                                   PAIR ;

                                                   PAIR ;

                                                   LEFT nat } } ;

                                   { DIP 4 { DUP } ; DIG 5 } ;

                                   PUSH nat 10000 ;

                                   SUB ;

                                   ABS ;

                                   PUSH nat 1 ;

                                   { DIP 7 { DUP } ; DIG 8 } ;

                                   SUB ;

                                   ABS ;

                                   PUSH nat 10000 ;

                                   PUSH nat 1 ;

                                   PAIR ;

                                   PAIR ;

                                   LEFT nat ;

                                   LOOP_LEFT { { { DUP ; CAR ; DIP { CDR } } } ;

                                               { { DUP ; CAR ; DIP { CDR } } } ;

                                               PUSH nat 0 ;

                                               { DIP 3 { DUP } ; DIG 4 } ;

                                               COMPARE ;

                                               EQ ;

                                               IF

                                                 { SWAP ;

                                                   DIG 2 ;

                                                   DROP 2 ;

                                                   RIGHT (pair (pair nat nat) nat) }

                                                 { PUSH nat 1 ;

                                                   DIG 3 ;

                                                   SUB ;

                                                   ABS ;

                                                   DIG 2 ;

                                                   DUP ;

                                                   DIG 3 ;

                                                   MUL ;

                                                   PAIR ;

                                                   PAIR ;

                                                   LEFT nat } } ;

                                   SWAP ;

                                   MUL ;

                                   { DIP 6 { DUP } ; DIG 7 } ;

                                   { DIP 6 { DUP } ; DIG 7 } ;

                                   PUSH nat 1 ;

                                   PAIR ;

                                   PAIR ;

                                   LEFT nat ;

                                   LOOP_LEFT { { { DUP ; CAR ; DIP { CDR } } } ;

                                               { { DUP ; CAR ; DIP { CDR } } } ;

                                               PUSH nat 0 ;

                                               { DIP 3 { DUP } ; DIG 4 } ;

                                               COMPARE ;

                                               EQ ;

                                               IF

                                                 { SWAP ;

                                                   DIG 2 ;

                                                   DROP 2 ;

                                                   RIGHT (pair (pair nat nat) nat) }

                                                 { PUSH nat 1 ;

                                                   DIG 3 ;

                                                   SUB ;

                                                   ABS ;

                                                   DIG 2 ;

                                                   DUP ;

                                                   DIG 3 ;

                                                   MUL ;

                                                   PAIR ;

                                                   PAIR ;

                                                   LEFT nat } } ;

                                   { DIP 7 { DUP } ; DIG 8 } ;

                                   PUSH nat 10000 ;

                                   PUSH nat 1 ;

                                   PAIR ;

                                   PAIR ;

                                   LEFT nat ;

                                   LOOP_LEFT { { { DUP ; CAR ; DIP { CDR } } } ;

                                               { { DUP ; CAR ; DIP { CDR } } } ;

                                               PUSH nat 0 ;

                                               { DIP 3 { DUP } ; DIG 4 } ;

                                               COMPARE ;

                                               EQ ;

                                               IF

                                                 { SWAP ;

                                                   DIG 2 ;

                                                   DROP 2 ;

                                                   RIGHT (pair (pair nat nat) nat) }

                                                 { PUSH nat 1 ;

                                                   DIG 3 ;

                                                   SUB ;

                                                   ABS ;

                                                   DIG 2 ;

                                                   DUP ;

                                                   DIG 3 ;

                                                   MUL ;

                                                   PAIR ;

                                                   PAIR ;

                                                   LEFT nat } } ;

                                   SUB ;

                                   ABS ;

                                   DIG 2 ;

                                   MUL ;

                                   DIG 2 ;

                                   { DIP 10 { DUP } ; DIG 11 } ;

                                   DIG 3 ;

                                   MUL ;

                                   MUL ;

                                   EDIV ;

                                   IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ;

                                   CAR ;

                                   CONS ;

                                   PUSH nat 1 ;

                                   DIG 2 ;

                                   SUB ;

                                   ABS ;

                                   PAIR ;

                                   LEFT (list nat) } } ;

                   SWAP ;

                   DIG 2 ;

                   DROP 2 ;

                   PUSH nat 1 ;

                   DIG 2 ;

                   SUB ;

                   ABS ;

                   SWAP ;

                   PAIR ;

                   LEFT (list nat) ;

                   LOOP_LEFT { { { DUP ; CAR ; DIP { CDR } } } ;

                               PUSH nat 0 ;

                               { DIP 2 { DUP } ; DIG 3 } ;

                               COMPARE ;

                               EQ ;

                               IF

                                 { SWAP ; DROP ; RIGHT (pair (list nat) nat) }

                                 { PUSH nat 1 ;

                                   DIG 2 ;

                                   SUB ;

                                   ABS ;

                                   SWAP ;

                                   PUSH nat 0 ;

                                   CONS ;

                                   PAIR ;

                                   LEFT (list nat) } } ;

                   NIL nat ;

                   NIL nat ;

                   DIG 2 ;

                   { DIP 6 { DUP } ; DIG 7 } ;

                   CAR ;

                   CDR ;

                   CDR ;

                   CDR ;

                   PAIR ;

                   PAIR ;

                   LEFT (list nat) ;

                   LOOP_LEFT { { { DUP ; CAR ; DIP { CDR } } } ;

                               { { DUP ; CAR ; DIP { CDR } } } ;

                               IF_CONS

                                 { DIG 2 ;

                                   IF_CONS

                                     { PUSH bool True ;

                                       PUSH bool True ;

                                       COMPARE ;

                                       EQ ;

                                       IF { DIG 2 ; ADD } { DIG 2 ; SUB ; ABS } ;

                                       DIG 3 ;

                                       SWAP ;

                                       CONS ;

                                       SWAP ;

                                       DIG 2 ;

                                       PAIR ;

                                       PAIR ;

                                       LEFT (list nat) }

                                     { DROP 3 ; PUSH string "size don't match" ; FAILWITH } }

                                 { IF_CONS

                                     { DROP 3 ; PUSH string "size don't match" ; FAILWITH }

                                     { RIGHT (pair (pair (list nat) (list nat))

                                                   (list nat)) } } } ;

                   PAIR ;

                   LEFT (list nat) ;

                   LOOP_LEFT { { { DUP ; CAR ; DIP { CDR } } } ;

                               IF_CONS

                                 { DIG 2 ; SWAP ; CONS ; SWAP ; PAIR ; LEFT (list nat) }

                                 { RIGHT (pair (list nat) (list nat)) } } ;

                   { DIP 4 { DUP } ; DIG 5 } ;

                   CDR ;

                   CDR ;

                   { DIP 4 { DUP } ; DIG 5 } ;

                   { DIP 6 { DUP } ; DIG 7 } ;

                   CDR ;

                   CAR ;

                   CDR ;

                   CDR ;

                   ADD ;

                   { DIP 6 { DUP } ; DIG 7 } ;

                   CDR ;

                   CAR ;

                   CDR ;

                   CAR ;

                   PAIR ;

                   { DIP 6 { DUP } ; DIG 7 } ;

                   CDR ;

                   CAR ;

                   CAR ;

                   PAIR ;

                   PAIR ;

                   DIG 5 ;

                   CAR ;

                   PAIR ;

                   DUP ;

                   CDR ;

                   DUG 2 ;

                   DUP ;

                   DUG 3 ;

                   CAR ;

                   CDR ;

                   CDR ;

                   CAR ;

                   PAIR ;

                   { DIP 2 { DUP } ; DIG 3 } ;

                   CAR ;

                   CDR ;

                   CAR ;

                   PAIR ;

                   DIG 2 ;

                   CAR ;

                   CAR ;

                   PAIR ;

                   PAIR ;

                   DUP ;

                   CDR ;

                   SWAP ;

                   DUP ;

                   DUG 2 ;

                   CAR ;

                   CDR ;

                   { DIP 2 { DUP } ; DIG 3 } ;

                   CAR ;

                   CAR ;

                   CDR ;

                   PUSH nat 0 ;

                   DIG 7 ;

                   COMPARE ;

                   EQ ;

                   IF { DIG 4 ; DROP ; DIG 4 } { DIG 5 ; DROP ; DIG 4 } ;

                   DIG 4 ;

                   CAR ;

                   CAR ;

                   CAR ;

                   CAR ;

                   PAIR ;

                   PAIR ;

                   PAIR ;

                   PAIR ;

                   NIL operation ;

                   PAIR } }

             { IF_LEFT

                 { DROP ;

                   NOW ;

                   SWAP ;

                   DUP ;

                   DUG 2 ;

                   CAR ;

                   CAR ;

                   CAR ;

                   CDR ;

                   NOW ;

                   SUB ;

                   ABS ;

                   PUSH nat 1 ;

                   { DIP 3 { DUP } ; DIG 4 } ;

                   CDR ;

                   CDR ;

                   CDR ;

                   CDR ;

                   DIG 2 ;

                   EDIV ;

                   IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ;

                   CAR ;

                   ADD ;

                   DROP ;

                   PUSH string "Only the contract admin can change the contract administrator or increase reward" ;

                   { DIP 2 { DUP } ; DIG 3 } ;

                   CAR ;

                   CAR ;

                   CAR ;

                   CAR ;

                   SENDER ;

                   COMPARE ;

                   EQ ;

                   IF { DROP } { FAILWITH } ;

                   PUSH string "You must not send Tezos to the smart contract" ;

                   PUSH mutez 0 ;

                   AMOUNT ;