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 (pair (address %admin) (timestamp %creation_time))

                    (list %farm_points nat)

                    (bool %initialized))

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

              (big_map %metadata string bytes)

              (nat %period_duration))

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

                  (option %reward_fa2_token_id_opt nat)

                  (address %reward_reserve_address))

            (pair (address %reward_token_address) (nat %total_periods))

            (nat %total_reward)

            (big_map %user_points address (list nat)))

          (big_map %user_stakes address nat));

code { PUSH bool True ;

       PUSH bool False ;

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

       PUSH string "Cannot connect to the input token entrypoint" ;

       PUSH string "Cannot connect to the input FA2 token entrypoint" ;

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

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

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

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

       PUSH string "The contract is already initialized" ;

       PUSH string "The contract is not initialized" ;

       NIL operation ;

       NIL nat ;

       LAMBDA

         (pair

           (pair

             (pair (pair (pair address timestamp) (list nat) bool)

                   (pair (option nat) address)

                   (big_map string bytes)

                   nat)

             (pair (pair nat (list nat)) (option nat) address)

             (pair address nat)

             nat

             (big_map address (list nat)))

           (big_map address nat))

         nat

         { DUP ;

           CAR ;

           CAR ;

           CAR ;

           CAR ;

           CDR ;

           NOW ;

           SUB ;

           ABS ;

           PUSH nat 1 ;

           DIG 2 ;

           CAR ;

           CAR ;

           CDR ;

           CDR ;

           CDR ;

           DIG 2 ;

           EDIV ;

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

           CAR ;

           ADD } ;

       LAMBDA

         (pair nat nat)

         nat

         { UNPAIR ;

           PUSH nat 1 ;

           PAIR ;

           PAIR ;

           LEFT nat ;

           LOOP_LEFT { UNPAIR ;

                       UNPAIR ;

                       PUSH nat 0 ;

                       DUP 4 ;

                       COMPARE ;

                       EQ ;

                       IF

                         { SWAP ; DIG 2 ; DROP 2 ; RIGHT (pair (pair nat nat) nat) }

                         { PUSH nat 1 ; DIG 3 ; SUB ; ABS ; DUP 3 ; DIG 3 ; DIG 3 ; MUL ; PAIR ; PAIR ; LEFT nat } } } ;

       LAMBDA

         (pair (list nat) (list nat))

         (list nat)

         { LEFT (list nat) ;

           LOOP_LEFT { UNPAIR ;

                       IF_CONS

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

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

       LAMBDA

         (pair (pair (lambda (pair (list nat) (list nat)) (list nat)) (list nat) bool)

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

         (list nat)

         { UNPAIR ;

           UNPAIR 3 ;

           DIG 3 ;

           UNPAIR 3 ;

           DUP 5 ;

           DIG 5 ;

           DIG 3 ;

           DIG 3 ;

           PAIR ;

           PAIR ;

           LEFT (list nat) ;

           LOOP_LEFT { UNPAIR ;

                       UNPAIR ;

                       IF_CONS

                         { DIG 2 ;

                           IF_CONS

                             { DUP 9 ;

                               DUP 8 ;

                               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)) } } ;

           DIG 2 ;

           DIG 4 ;

           DROP 2 ;

           PAIR ;

           EXEC } ;

       DUP 17 ;

       DUP 6 ;

       DUP 4 ;

       PAIR 3 ;

       APPLY ;

       LAMBDA

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

         (list nat)

         { UNPAIR ;

           UNPAIR ;

           DIG 2 ;

           UNPAIR 3 ;

           DIG 4 ;

           DUP 3 ;

           PAIR ;

           LEFT (list nat) ;

           LOOP_LEFT { UNPAIR ;

                       PUSH nat 0 ;

                       DUP 2 ;

                       COMPARE ;

                       EQ ;

                       IF

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

                         { SWAP ;

                           PUSH nat 1 ;

                           DUP 3 ;

                           SUB ;

                           ABS ;

                           DUP 6 ;

                           PAIR ;

                           DUP 7 ;

                           SWAP ;

                           EXEC ;

                           PUSH nat 1 ;

                           DUP 4 ;

                           SUB ;

                           ABS ;

                           PUSH nat 10000 ;

                           PAIR ;

                           DUP 8 ;

                           SWAP ;

                           EXEC ;

                           DUP 7 ;

                           PUSH nat 10000 ;

                           SUB ;

                           ABS ;

                           PUSH nat 1 ;

                           DUP 8 ;

                           SUB ;

                           ABS ;

                           PUSH nat 10000 ;

                           PAIR ;

                           DUP 10 ;

                           SWAP ;

                           EXEC ;

                           SWAP ;

                           MUL ;

                           DUP 7 ;

                           DUP 9 ;

                           PAIR ;

                           DUP 10 ;

                           SWAP ;

                           EXEC ;

                           DUP 8 ;

                           PUSH nat 10000 ;

                           PAIR ;

                           DUP 11 ;

                           SWAP ;

                           EXEC ;

                           SUB ;

                           ABS ;

                           DIG 2 ;

                           MUL ;

                           DIG 2 ;

                           DUP 6 ;

                           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 ;

           DIG 3 ;

           DIG 4 ;

           DROP 4 } ;

       DUP 6 ;

       DUP 5 ;

       PAIR ;

       APPLY ;

       DIG 3 ;

       DROP ;

       DIG 17 ;

       UNPAIR ;

       IF_LEFT

         { IF_LEFT

             { DIG 9 ;

               DIG 14 ;

               DIG 15 ;

               DIG 17 ;

               DROP 4 ;

               IF_LEFT

                 { DIG 2 ;

                   DIG 3 ;

                   DIG 9 ;

                   DIG 13 ;

                   DROP 5 ;

                   DIG 9 ;

                   DUP 2 ;

                   CAR ;

                   CAR ;

                   CAR ;

                   CDR ;

                   CDR ;

                   COMPARE ;

                   EQ ;

                   IF { DIG 5 ; DROP } { DIG 5 ; FAILWITH } ;

                   SENDER ;

                   DUP 2 ;

                   DIG 4 ;

                   SWAP ;

                   EXEC ;

                   PUSH nat 1 ;

                   DUP 2 ;

                   COMPARE ;

                   GT ;

                   IF

                     {}

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

                       FAILWITH } ;

                   DIG 6 ;

                   PUSH mutez 0 ;

                   AMOUNT ;

                   COMPARE ;

                   EQ ;

                   IF { DROP } { FAILWITH } ;

                   PUSH nat 1 ;

                   SWAP ;

                   SUB ;

                   ABS ;

                   DUP 3 ;

                   CAR ;

                   CDR ;

                   CDR ;

                   CDR ;

                   CDR ;

                   DUP 3 ;

                   GET ;

                   IF_NONE

                     { SWAP ; DIG 3 ; DIG 4 ; DIG 6 ; DIG 7 ; DROP 6 ; SWAP }

                     { DUP 4 ;

                       CAR ;

                       CDR ;

                       CAR ;

                       CAR ;

                       CDR ;

                       DUP 5 ;

                       CAR ;

                       CAR ;

                       CAR ;

                       CDR ;

                       CAR ;

                       DUP 3 ;

                       PAIR ;

                       DUP 4 ;

                       PUSH nat 0 ;

                       PAIR ;

                       PAIR ;

                       PAIR ;

                       LEFT nat ;

                       LOOP_LEFT { UNPAIR ;

                                   UNPAIR ;

                                   UNPAIR ;

                                   DIG 2 ;

                                   UNPAIR ;

                                   IF_CONS

                                     { DIG 2 ;

                                       IF_CONS

                                         { DIG 6 ;

                                           IF_CONS

                                             { PUSH nat 0 ;

                                               DUP 9 ;

                                               COMPARE ;

                                               GT ;

                                               IF

                                                 { PUSH nat 0 ;

                                                   DUP 4 ;

                                                   COMPARE ;

                                                   EQ ;

                                                   IF

                                                     { DIG 2 ;

                                                       DIG 4 ;

                                                       DROP 3 ;

                                                       SWAP ;

                                                       DIG 2 ;

                                                       PAIR ;

                                                       PUSH nat 1 ;

                                                       DIG 4 ;

                                                       SUB }

                                                     { 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)

                                                                 (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 2 ;

                                       DROP ;

                                       IF_CONS

                                         { DROP 4 ;

                                           PUSH string "size don't match" ;

                                           FAILWITH }

                                         { SWAP ;

                                           IF_CONS

                                             { DROP 3 ;

                                               PUSH string "size don't match" ;

                                               FAILWITH }

                                             {} } ;

                                       RIGHT (pair

                                               (pair (pair nat nat) (list nat)

                                                     (list nat))

                                               (list nat)) } } ;

                       DUP 5 ;

                       CAR ;

                       CDR ;

                       CAR ;

                       CDR ;

                       CDR ;

                       DUP 6 ;

                       CAR ;

                       CDR ;

                       CDR ;

                       CAR ;

                       CAR ;

                       DUP 7 ;

                       CAR ;

                       CDR ;

                       CAR ;

                       CDR ;

                       CAR ;

                       IF_NONE

                         { DIG 10 ;

                           DROP ;

                           CONTRACT %transfer (pair address address nat) ;

                           IF_NONE { DIG 9 ; FAILWITH } { DIG 10 ; DROP } ;

                           PUSH mutez 0 ;

                           DUP 4 ;

                           DUP 8 ;

                           PAIR ;

                           DIG 3 ;

                           PAIR ;

                           TRANSFER_TOKENS }

                         { DIG 12 ;

                           DROP ;

                           SWAP ;

                           CONTRACT %transfer (list (pair address

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

                           IF_NONE { DIG 10 ; FAILWITH } { DIG 11 ; DROP } ;

                           PUSH mutez 0 ;

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

                           NIL (pair address nat nat) ;

                           DUP 7 ;

                           DIG 5 ;

                           PAIR ;

                           DUP 10 ;

                           PAIR ;

                           CONS ;

                           DIG 4 ;

                           PAIR ;

                           CONS ;

                           TRANSFER_TOKENS } ;

                       PUSH nat 0 ;

                       DIG 2 ;

                       COMPARE ;

                       EQ ;

                       IF

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

                         { DIG 7 ;

                           DROP ;

                           DUP 7 ;

                           DIG 2 ;

                           DIG 3 ;

                           DIG 7 ;

                           PAIR ;

                           PAIR ;

                           LEFT (list nat) ;

                           LOOP_LEFT { UNPAIR ;

                                       UNPAIR ;

                                       DIG 2 ;

                                       IF_CONS

                                         { PUSH nat 0 ;

                                           DUP 5 ;

                                           COMPARE ;

                                           GT ;

                                           IF

                                             { DROP ;

                                               PUSH nat 1 ;

                                               DIG 3 ;

                                               SUB ;

                                               ABS ;

                                               DIG 2 ;

                                               PUSH nat 0 }

                                             { SWAP ; DUG 3 } ;

                                           CONS ;

                                           PAIR ;

                                           PAIR ;

                                           LEFT (list nat) }

                                         { SWAP ;

                                           DROP ;

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

                           PAIR ;

                           DIG 4 ;

                           SWAP ;

                           EXEC ;

                           DUP 4 ;

                           DUP 5 ;

                           CAR ;

                           DUP ;

                           CDR ;

                           DUP ;

                           CDR ;

                           DUP ;

                           CDR ;

                           DIG 8 ;

                           CAR ;

                           CDR ;

                           CDR ;

                           CDR ;

                           CDR ;

                           DIG 6 ;

                           SOME ;

                           DIG 8 ;

                           UPDATE ;

                           UPDATE 2 ;

                           UPDATE 2 ;

                           UPDATE 2 ;

                           UPDATE 2 ;

                           UPDATE 1 ;

                           NIL operation ;

                           DIG 2 ;

                           CONS } } }

                 { DIG 4 ;

                   DIG 6 ;

                   DIG 11 ;

                   DIG 12 ;

                   DROP 4 ;

                   DUP 2 ;

                   CAR ;

                   CDR ;

                   CDR ;

                   CAR ;

                   CDR ;

                   NOW ;

                   DUP 4 ;

                   CAR ;

                   CAR ;

                   CAR ;

                   CAR ;

                   CDR ;

                   DUP 5 ;

                   DIG 8 ;

                   SWAP ;

                   EXEC ;

                   DUP 14 ;

                   DUP 7 ;

                   CAR ;

                   CAR ;

                   CAR ;

                   CDR ;

                   CDR ;

                   COMPARE ;

                   EQ ;

                   IF { DIG 9 ; DROP } { DIG 9 ; FAILWITH } ;

                   DIG 11 ;

                   DUP 7 ;

                   CAR ;

                   CAR ;

                   CAR ;

                   CAR ;

                   CAR ;

                   SENDER ;

                   COMPARE ;

                   EQ ;

                   IF { DROP } { FAILWITH } ;

                   DIG 10 ;

                   PUSH mutez 0 ;

                   AMOUNT ;

                   COMPARE ;

                   EQ ;

                   IF { DROP } { FAILWITH } ;

                   DIG 9 ;

                   DUP 7 ;

                   CAR ;

                   CAR ;

                   CDR ;

                   CDR ;

                   CDR ;

                   DUP 6 ;

                   MUL ;

                   INT ;

                   DUP 4 ;

                   ADD ;

                   DUP 5 ;

                   COMPARE ;

                   LT ;

                   IF { DROP } { FAILWITH } ;

                   PUSH nat 0 ;

                   DUP 6 ;

                   COMPARE ;

                   GT ;

                   IF

                     {}

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

                       FAILWITH } ;

                   PUSH nat 1 ;

                   DUP 2 ;

                   DIG 5 ;

                   SUB ;

                   ABS ;

                   ADD ;

                   DUP 6 ;

                   CAR ;

                   CDR ;

                   CAR ;

                   CAR ;

                   CAR ;

                   SWAP ;

                   DUP 6 ;

                   PAIR 3 ;

                   DIG 6 ;

                   SWAP ;

                   EXEC ;

                   PUSH nat 1 ;

                   DIG 2 ;

                   SUB ;

                   ABS ;

                   SWAP ;

                   PAIR ;

                   LEFT (list nat) ;

                   LOOP_LEFT { UNPAIR ;

                               PUSH nat 0 ;

                               DUP 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) } } ;

                   DIG 7 ;

                   SWAP ;

                   DUP 6 ;

                   CAR ;

                   CDR ;

                   CAR ;

                   CAR ;

                   CDR ;

                   PAIR 3 ;

                   DIG 5 ;

                   SWAP ;

                   EXEC ;

                   DUP 5 ;

                   DUP 6 ;

                   CAR ;

                   DUP ;

                   CDR ;

                   DUP ;

                   CDR ;

                   DUP ;

                   CDR ;

                   DUP 9 ;

                   DIG 10 ;

                   CAR ;

                   CDR ;

                   CDR ;

                   CDR ;

                   CAR ;

                   ADD ;

                   UPDATE 1 ;

                   UPDATE 2 ;

                   UPDATE 2 ;

                   UPDATE 2 ;

                   UPDATE 1 ;

                   DUP ;

                   CAR ;

                   DUP ;

                   CDR ;

                   DUP ;

                   CAR ;

                   DUP ;

                   CAR ;

                   DIG 5 ;

                   UPDATE 2 ;

                   UPDATE 1 ;

                   UPDATE 1 ;

                   UPDATE 2 ;

                   UPDATE 1 ;

                   DUP ;

                   CAR ;

                   DUP ;

                   CAR ;

                   DUP ;

                   CAR ;

                   DUP ;

                   CAR ;

                   PUSH nat 0 ;

                   DIG 8 ;

                   COMPARE ;

                   EQ ;

                   IF { DIG 5 ; DROP } { DIG 6 ; DROP } ;

                   DIG 5 ;

                   UPDATE 2 ;

                   UPDATE 1 ;

                   UPDATE 1 ;

                   UPDATE 1 ;

                   UPDATE 1 ;

                   SWAP } }

             { DIG 3 ;

               DIG 4 ;

               DIG 6 ;

               DIG 8 ;

               DROP 4 ;

               IF_LEFT

                 { DROP ;

                   NOW ;

                   DUP 2 ;

                   DIG 4 ;

                   SWAP ;

                   EXEC ;

                   DROP ;

                   DIG 11 ;

                   DUP 3 ;

                   CAR ;

                   CAR ;

                   CAR ;

                   CAR ;

                   CAR ;

                   SENDER ;

                   COMPARE ;

                   EQ ;

                   IF { DROP } { FAILWITH } ;

                   DIG 6 ;

                   PUSH mutez 0 ;

                   AMOUNT ;

                   COMPARE ;

                   EQ ;

                   IF { DROP } { FAILWITH } ;

                   DIG 5 ;

                   DUP 3 ;

                   CAR ;

                   CAR ;

                   CDR ;

                   CDR ;

                   CDR ;

                   INT ;

                   DUP 4 ;

                   CAR ;

                   CAR ;

                   CAR ;

                   CAR ;

                   CDR ;

                   ADD ;

                   DUP 3 ;

                   COMPARE ;

                   LT ;

                   IF { DROP } { FAILWITH } ;

                   PUSH nat 0 ;

                   DUP 3 ;

                   CAR ;

                   CDR ;

                   CAR ;

                   CAR ;

                   CDR ;

                   SIZE ;

                   COMPARE ;

                   EQ ;

                   IF {} { DUP 5 ; FAILWITH } ;

                   DIG 9 ;

                   DUP 3 ;

                   CAR ;

                   CAR ;

                   CAR ;

                   CDR ;

                   CDR ;

                   COMPARE ;

                   EQ ;

                   IF { DIG 4 ; DROP } { DIG 4 ; FAILWITH } ;

                   DUP 2 ;

                   CAR ;

                   CDR ;

                   CAR ;

                   CAR ;

                   CAR ;

                   DUP 3 ;

                   CAR ;

                   CDR ;

                   CDR ;

                   CAR ;

                   CDR ;

                   DUP 4 ;

                   CAR ;

                   CDR ;

                   CDR ;

                   CDR ;

                   CAR ;

                   PAIR 3 ;

                   DIG 3 ;

                   SWAP ;

                   EXEC ;

                   DUP 3 ;

                   CAR ;

                   CAR ;

                   CDR ;

                   CAR ;

                   CAR ;

                   IF_NONE

                     { DIG 6 ;

                       DROP ;

                       DUP 3 ;

                       CAR ;

                       CAR ;

                       CDR ;

                       CAR ;

                       CDR ;

                       CONTRACT %transfer (pair address address nat) ;

                       IF_NONE { DIG 6 ; FAILWITH } { DIG 7 ; DROP 2 } }

                     { DIG 8 ;

                       DROP 2 ;