parameter (or

            (or (or (unit %default) (address %deposit))

                (or (unit %reRoll)

                    (pair %register (address %investor) (address %referrar))))

            (or (or (key_hash %updateBaker) (address %updateInvestorBaker))

                (or (address %updateOwner) (or (mutez %withdraw) (unit %withdrawDevFee)))));

storage (pair

          (pair (pair (key_hash %baker) (mutez %contractBalance))

                (pair (mutez %contractValue)

                      (pair (mutez %devBalance) (map %distributionPointsList int nat))))

          (pair

            (pair

              (pair %feeStrucutre

                (pair %deposit (pair (nat %devFee) (nat %distributionPoolFee))

                               (pair (nat %referralFee) (nat %rewardPoolFee)))

                (pair %withdraw (pair (nat %devFee) (nat %distributionPoolFee))

                                (pair (nat %referralFee) (nat %rewardPoolFee))))

              (map %investors address

                              (pair

                                (pair (pair (mutez %balance) (address %contract))

                                      (pair (nat %distributionPoolLength)

                                            (timestamp %lastUpdateAt)))

                                (pair

                                  (pair (map %lockedBalance mutez timestamp)

                                        (mutez %reRollBalance))

                                  (pair (address %referrar) (nat %rewardPoolLength))))))

            (pair (address %owner)

                  (pair (map %rewardPoolPointsList int nat) (int %rewardPoolUnlockAfter)))));

code { DUP ;

       CDR ;

       SWAP ;

       CAR ;

       IF_LEFT

         { IF_LEFT

             { IF_LEFT

                 { DROP ;

                   PUSH mutez 0 ;

                   AMOUNT ;

                   COMPARE ;

                   GT ;

                   IF {} { PUSH int 400 ; FAILWITH } ;

                   NIL operation }

                 { PUSH mutez 0 ;

                   AMOUNT ;

                   COMPARE ;

                   GT ;

                   IF {} { PUSH int 422 ; FAILWITH } ;

                   PUSH nat 0 ;

                   PUSH nat 0 ;

                   DIG 3 ;

                   DUP ;

                   DUG 4 ;

                   CDR ;

                   CAR ;

                   CDR ;

                   DIG 3 ;

                   DUP ;

                   DUG 4 ;

                   GET ;

                   IF_NONE { PUSH int 208 ; FAILWITH } {} ;

                   CAR ;

                   CDR ;

                   CAR ;

                   COMPARE ;

                   GT ;

                   IF

                     { DIG 2 ;

                       DUP ;

                       DUG 3 ;

                       CAR ;

                       CDR ;

                       CDR ;

                       CDR ;

                       SIZE ;

                       INT ;

                       PUSH nat 1 ;

                       DIG 4 ;

                       DUP ;

                       DUG 5 ;

                       CDR ;

                       CAR ;

                       CDR ;

                       DIG 4 ;

                       DUP ;

                       DUG 5 ;

                       GET ;

                       IF_NONE { PUSH int 208 ; FAILWITH } {} ;

                       CAR ;

                       CDR ;

                       CAR ;

                       SUB ;

                       DUP ;

                       DIG 2 ;

                       DUP ;

                       DUG 3 ;

                       COMPARE ;

                       GT ;

                       LOOP { DIG 4 ;

                              DUP ;

                              DUG 5 ;

                              CAR ;

                              CDR ;

                              CDR ;

                              CDR ;

                              SWAP ;

                              DUP ;

                              DUG 2 ;

                              GET ;

                              IF_NONE { PUSH int 167 ; FAILWITH } {} ;

                              DIG 3 ;

                              ADD ;

                              DUG 2 ;

                              PUSH int 1 ;

                              ADD ;

                              DUP ;

                              DIG 2 ;

                              DUP ;

                              DUG 3 ;

                              COMPARE ;

                              GT } ;

                       DROP 2 }

                     {} ;

                   PUSH mutez 0 ;

                   DIG 3 ;

                   DUP ;

                   DUG 4 ;

                   CDR ;

                   CAR ;

                   CDR ;

                   DIG 3 ;

                   DUP ;

                   DUG 4 ;

                   GET ;

                   IF_NONE { PUSH int 208 ; FAILWITH } {} ;

                   CDR ;

                   CAR ;

                   CAR ;

                   ITER { DUP ;

                          CDR ;

                          NOW ;

                          SWAP ;

                          COMPARE ;

                          LE ;

                          IF

                            { DUP ;

                              CAR ;

                              DIG 2 ;

                              ADD ;

                              SWAP ;

                              DIG 4 ;

                              DUP ;

                              CAR ;

                              SWAP ;

                              CDR ;

                              DUP ;

                              CDR ;

                              SWAP ;

                              CAR ;

                              DUP ;

                              CAR ;

                              SWAP ;

                              CDR ;

                              DUP ;

                              DIG 8 ;

                              DUP ;

                              DUG 9 ;

                              DUP ;

                              DUG 2 ;

                              GET ;

                              IF_NONE { PUSH int 176 ; FAILWITH } {} ;

                              DUP ;

                              CAR ;

                              SWAP ;

                              CDR ;

                              DUP ;

                              CDR ;

                              SWAP ;

                              CAR ;

                              DUP ;

                              CDR ;

                              SWAP ;

                              CAR ;

                              NONE timestamp ;

                              DIG 10 ;

                              CAR ;

                              UPDATE ;

                              PAIR ;

                              PAIR ;

                              SWAP ;

                              PAIR ;

                              SOME ;

                              SWAP ;

                              UPDATE ;

                              SWAP ;

                              PAIR ;

                              PAIR ;

                              SWAP ;

                              PAIR ;

                              DUG 3 }

                            { DROP } } ;

                   PUSH nat 0 ;

                   PUSH nat 0 ;

                   DIG 5 ;

                   DUP ;

                   DUG 6 ;

                   CDR ;

                   CAR ;

                   CDR ;

                   DIG 5 ;

                   DUP ;

                   DUG 6 ;

                   GET ;

                   IF_NONE { PUSH int 208 ; FAILWITH } {} ;

                   CDR ;

                   CDR ;

                   CDR ;

                   COMPARE ;

                   GT ;

                   IF

                     { DIG 4 ;

                       DUP ;

                       DUG 5 ;

                       CDR ;

                       CDR ;

                       CDR ;

                       CAR ;

                       SIZE ;

                       INT ;

                       PUSH nat 1 ;

                       DIG 6 ;

                       DUP ;

                       DUG 7 ;

                       CDR ;

                       CAR ;

                       CDR ;

                       DIG 6 ;

                       DUP ;

                       DUG 7 ;

                       GET ;

                       IF_NONE { PUSH int 208 ; FAILWITH } {} ;

                       CDR ;

                       CDR ;

                       CDR ;

                       SUB ;

                       DUP ;

                       DIG 2 ;

                       DUP ;

                       DUG 3 ;

                       COMPARE ;

                       GT ;

                       LOOP { DIG 6 ;

                              DUP ;

                              DUG 7 ;

                              CDR ;

                              CDR ;

                              CDR ;

                              CAR ;

                              SWAP ;

                              DUP ;

                              DUG 2 ;

                              GET ;

                              IF_NONE { PUSH int 182 ; FAILWITH } {} ;

                              DIG 3 ;

                              ADD ;

                              DUG 2 ;

                              PUSH int 1 ;

                              ADD ;

                              DUP ;

                              DIG 2 ;

                              DUP ;

                              DUG 3 ;

                              COMPARE ;

                              GT } ;

                       DROP 2 }

                     {} ;

                   PUSH mutez 0 ;

                   PUSH nat 1000000 ;

                   DIG 6 ;

                   DUP ;

                   DUG 7 ;

                   CDR ;

                   CAR ;

                   CDR ;

                   DIG 6 ;

                   DUP ;

                   DUG 7 ;

                   GET ;

                   IF_NONE { PUSH int 208 ; FAILWITH } {} ;

                   CAR ;

                   CAR ;

                   CAR ;

                   EDIV ;

                   IF_NONE { PUSH int 198 ; FAILWITH } {} ;

                   CAR ;

                   DIG 2 ;

                   DUP ;

                   DUG 3 ;

                   MUL ;

                   COMPARE ;

                   GT ;

                   IF

                     { DIG 4 ;

                       DUP ;

                       CDR ;

                       CDR ;

                       CDR ;

                       CDR ;

                       SWAP ;

                       DUP ;

                       DUG 6 ;

                       CDR ;

                       CAR ;

                       CDR ;

                       DIG 5 ;

                       DUP ;

                       DUG 6 ;

                       GET ;

                       IF_NONE { PUSH int 208 ; FAILWITH } {} ;

                       CAR ;

                       CDR ;

                       CDR ;

                       NOW ;

                       SUB ;

                       COMPARE ;

                       GE ;

                       IF

                         { PUSH nat 1000000 ;

                           DIG 5 ;

                           DUP ;

                           DUG 6 ;

                           CDR ;

                           CAR ;

                           CDR ;

                           DIG 5 ;

                           DUP ;

                           DUG 6 ;

                           GET ;

                           IF_NONE { PUSH int 208 ; FAILWITH } {} ;

                           CAR ;

                           CAR ;

                           CAR ;

                           EDIV ;

                           IF_NONE { PUSH int 198 ; FAILWITH } {} ;

                           CAR ;

                           SWAP ;

                           DUP ;

                           DUG 2 ;

                           MUL ;

                           DIG 2 ;

                           ADD ;

                           SWAP }

                         { DIG 4 ;

                           DUP ;

                           DUG 5 ;

                           DUP ;

                           CAR ;

                           SWAP ;

                           CDR ;

                           DUP ;

                           CDR ;

                           SWAP ;

                           CAR ;

                           DUP ;

                           CAR ;

                           SWAP ;

                           CDR ;

                           DUP ;

                           DIG 8 ;

                           DUP ;

                           DUG 9 ;

                           DUP ;

                           DUG 2 ;

                           GET ;

                           IF_NONE { PUSH int 190 ; FAILWITH } {} ;

                           DUP ;

                           CAR ;

                           SWAP ;

                           CDR ;

                           DUP ;

                           CDR ;

                           SWAP ;

                           CAR ;

                           DUP ;

                           CDR ;

                           SWAP ;

                           CAR ;

                           PUSH nat 1000000 ;

                           DIG 14 ;

                           DUP ;

                           DUG 15 ;

                           CDR ;

                           CAR ;

                           CDR ;

                           DIG 6 ;

                           DUP ;

                           DUG 7 ;

                           GET ;

                           IF_NONE { PUSH int 208 ; FAILWITH } {} ;

                           CAR ;

                           CAR ;

                           CAR ;

                           EDIV ;

                           IF_NONE { PUSH int 198 ; FAILWITH } {} ;

                           CAR ;

                           DIG 10 ;

                           DUP ;

                           DUG 11 ;

                           MUL ;

                           DIG 14 ;

                           DUP ;

                           DUG 15 ;

                           CDR ;

                           CAR ;

                           CDR ;

                           DIG 6 ;

                           DUP ;

                           DUG 7 ;

                           GET ;

                           IF_NONE { PUSH int 208 ; FAILWITH } {} ;

                           CAR ;

                           CDR ;

                           CDR ;

                           DIG 15 ;

                           CDR ;

                           CDR ;

                           CDR ;

                           CDR ;

                           ADD ;

                           SOME ;

                           SWAP ;

                           UPDATE ;

                           PAIR ;

                           PAIR ;

                           SWAP ;

                           PAIR ;

                           SOME ;

                           SWAP ;

                           UPDATE ;

                           SWAP ;

                           PAIR ;

                           PAIR ;

                           SWAP ;

                           PAIR ;

                           DUG 4 } }

                     {} ;

                   DIG 4 ;

                   DUP ;

                   CAR ;

                   SWAP ;

                   CDR ;

                   DUP ;

                   CDR ;

                   SWAP ;

                   CAR ;

                   DUP ;

                   CAR ;

                   SWAP ;

                   CDR ;

                   DUP ;

                   DIG 8 ;

                   DUP ;

                   DUG 9 ;

                   DUP ;

                   DUG 2 ;

                   GET ;

                   IF_NONE { PUSH int 192 ; FAILWITH } {} ;

                   DUP ;

                   CDR ;

                   SWAP ;

                   CAR ;

                   DUP ;

                   CAR ;

                   SWAP ;

                   CDR ;

                   CAR ;

                   NOW ;

                   SWAP ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   PAIR ;

                   SOME ;

                   SWAP ;

                   UPDATE ;

                   SWAP ;

                   PAIR ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   DUP ;

                   DUG 5 ;

                   DUP ;

                   CAR ;

                   SWAP ;

                   CDR ;

                   DUP ;

                   CDR ;

                   SWAP ;

                   CAR ;

                   DUP ;

                   CAR ;

                   SWAP ;

                   CDR ;

                   DUP ;

                   DIG 8 ;

                   DUP ;

                   DUG 9 ;

                   DUP ;

                   DUG 2 ;

                   GET ;

                   IF_NONE { PUSH int 289 ; FAILWITH } {} ;

                   DUP ;

                   CAR ;

                   SWAP ;

                   CDR ;

                   DUP ;

                   CDR ;

                   SWAP ;

                   CAR ;

                   DUP ;

                   CAR ;

                   SWAP ;

                   CDR ;

                   DIG 10 ;

                   DUP ;

                   DUG 11 ;

                   PUSH nat 1000000 ;

                   DIG 15 ;

                   CDR ;

                   CAR ;

                   CDR ;

                   DIG 7 ;

                   DUP ;

                   DUG 8 ;

                   GET ;

                   IF_NONE { PUSH int 208 ; FAILWITH } {} ;

                   CAR ;

                   CAR ;

                   CAR ;

                   EDIV ;

                   IF_NONE { PUSH int 198 ; FAILWITH } {} ;

                   CAR ;

                   DIG 13 ;

                   DUP ;

                   DUG 14 ;

                   MUL ;

                   ADD ;

                   ADD ;

                   SWAP ;

                   PAIR ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   SOME ;

                   SWAP ;

                   UPDATE ;

                   SWAP ;

                   PAIR ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   DUP ;

                   DUG 5 ;

                   CDR ;

                   CAR ;

                   CAR ;

                   CAR ;

                   CDR ;

                   CDR ;

                   DIG 5 ;

                   DUP ;

                   DUG 6 ;

                   CDR ;

                   CAR ;

                   CAR ;

                   CAR ;

                   CDR ;

                   CAR ;

                   SELF ;

                   ADDRESS ;

                   DIG 7 ;

                   DUP ;

                   DUG 8 ;

                   CDR ;

                   CAR ;

                   CDR ;

                   DIG 7 ;

                   DUP ;

                   DUG 8 ;

                   GET ;

                   IF_NONE { PUSH int 208 ; FAILWITH } {} ;

                   CDR ;

                   CDR ;

                   CAR ;

                   COMPARE ;

                   EQ ;

                   IF

                     { DROP ; DIG 5 ; DUP ; DUG 6 ; CDR ; CAR ; CAR ; CAR ; CDR ; CAR ; ADD ; PUSH nat 0 }

                     {} ;

                   PUSH nat 100 ;

                   AMOUNT ;

                   DIG 8 ;

                   DUP ;

                   DUG 9 ;

                   CDR ;

                   CAR ;

                   CAR ;

                   CAR ;

                   CAR ;

                   CAR ;

                   MUL ;

                   EDIV ;

                   IF_NONE { PUSH int 81 ; FAILWITH } {} ;

                   CAR ;

                   PUSH nat 100 ;

                   AMOUNT ;

                   DIG 3 ;

                   DUP ;

                   DUG 4 ;

                   MUL ;

                   EDIV ;

                   IF_NONE { PUSH int 81 ; FAILWITH } {} ;

                   CAR ;

                   PUSH nat 100 ;

                   AMOUNT ;

                   DIG 10 ;

                   DUP ;

                   DUG 11 ;

                   CDR ;

                   CAR ;

                   CAR ;

                   CAR ;

                   CAR ;

                   CDR ;

                   MUL ;

                   EDIV ;

                   IF_NONE { PUSH int 81 ; FAILWITH } {} ;

                   CAR ;

                   PUSH nat 100 ;

                   AMOUNT ;

                   DIG 6 ;

                   DUP ;

                   DUG 7 ;

                   MUL ;

                   EDIV ;

                   IF_NONE { PUSH int 81 ; FAILWITH } {} ;

                   CAR ;

                   ADD ;

                   ADD ;

                   ADD ;

                   AMOUNT ;

                   SUB ;

                   NIL operation ;

                   DIG 8 ;

                   DUP ;

                   DUG 9 ;

                   CDR ;

                   CAR ;

                   CDR ;

                   DIG 8 ;

                   DUP ;

                   DUG 9 ;

                   GET ;

                   IF_NONE { PUSH int 208 ; FAILWITH } {} ;

                   CAR ;

                   CAR ;

                   CDR ;

                   CONTRACT unit ;

                   IF_NONE { PUSH int 225 ; FAILWITH } {} ;

                   DIG 2 ;

                   DUP ;

                   DUG 3 ;

                   UNIT ;

                   TRANSFER_TOKENS ;

                   CONS ;

                   DIG 8 ;

                   DUP ;

                   CDR ;

                   SWAP ;

                   CAR ;

                   DUP ;

                   CAR ;

                   SWAP ;

                   CDR ;

                   DUP ;

                   CDR ;

                   SWAP ;

                   CAR ;

                   DIG 5 ;

                   DUP ;

                   DUG 6 ;

                   ADD ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   PAIR ;

                   DUP ;

                   CAR ;

                   SWAP ;

                   CDR ;

                   DUP ;

                   CDR ;

                   SWAP ;

                   CAR ;

                   DUP ;

                   CAR ;

                   SWAP ;

                   CDR ;

                   DUP ;

                   DIG 12 ;

                   DUP ;

                   DUG 13 ;

                   DUP ;

                   DUG 2 ;

                   GET ;

                   IF_NONE { PUSH int 228 ; FAILWITH } {} ;

                   DUP ;

                   CDR ;

                   SWAP ;

                   CAR ;

                   DUP ;

                   CDR ;

                   SWAP ;

                   CAR ;

                   DUP ;

                   CDR ;

                   SWAP ;

                   CAR ;

                   DIG 10 ;

                   DUP ;

                   DUG 11 ;

                   ADD ;

                   PAIR ;

                   PAIR ;

                   PAIR ;

                   SOME ;

                   SWAP ;

                   UPDATE ;

                   SWAP ;

                   PAIR ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   DUG 8 ;

                   PUSH nat 0 ;

                   PUSH nat 0 ;

                   PUSH mutez 0 ;

                   PUSH nat 1000000 ;

                   DIG 12 ;

                   DUP ;

                   DUG 13 ;

                   CAR ;

                   CDR ;

                   CAR ;

                   EDIV ;

                   IF_NONE { PUSH int 133 ; FAILWITH } {} ;

                   CAR ;

                   COMPARE ;

                   GT ;

                   IF

                     { DROP 2 ;

                       PUSH nat 1000000 ;

                       DIG 9 ;

                       DUP ;

                       DUG 10 ;

                       CAR ;

                       CDR ;

                       CAR ;

                       EDIV ;

                       IF_NONE { PUSH int 133 ; FAILWITH } {} ;

                       CAR ;

                       DIG 9 ;

                       DUP ;

                       DUG 10 ;

                       CAR ;

                       CAR ;

                       CDR ;

                       AMOUNT ;

                       BALANCE ;

                       SUB ;

                       SUB ;

                       PUSH nat 100 ;

                       AMOUNT ;

                       DIG 7 ;

                       DUP ;

                       DUG 8 ;

                       MUL ;

                       EDIV ;

                       IF_NONE { PUSH int 81 ; FAILWITH } {} ;

                       CAR ;

                       ADD ;

                       EDIV ;

                       IF_NONE { PUSH int 138 ; FAILWITH } {} ;

                       CAR ;

                       DUP ;

                       PUSH nat 0 ;

                       COMPARE ;

                       LT ;

                       IF

                         { DIG 9 ;

                           DUP ;

                           DUG 10 ;

                           DUP ;

                           CAR ;

                           SWAP ;

                           CDR ;

                           DUP ;

                           CAR ;

                           SWAP ;

                           CDR ;

                           DUP ;

                           CAR ;

                           SWAP ;

                           CDR ;

                           DUP ;

                           CDR ;

                           SWAP ;

                           CAR ;

                           DIG 14 ;

                           CDR ;

                           CDR ;

                           CDR ;

                           CAR ;

                           SIZE ;

                           INT ;

                           DIG 6 ;

                           DUP ;

                           DUG 7 ;

                           SOME ;

                           SWAP ;

                           UPDATE ;

                           PAIR ;

                           SWAP ;

                           PAIR ;

                           SWAP ;

                           PAIR ;

                           SWAP ;

                           PAIR ;

                           DUG 9 }

                         {} ;

                       PUSH nat 1000000 ;

                       DIG 10 ;

                       DUP ;

                       DUG 11 ;

                       CAR ;

                       CDR ;

                       CAR ;

                       EDIV ;

                       IF_NONE { PUSH int 133 ; FAILWITH } {} ;

                       CAR ;

                       PUSH nat 100 ;

                       AMOUNT ;

                       DIG 12 ;

                       DUP ;

                       DUG 13 ;

                       CDR ;

                       CAR ;

                       CAR ;

                       CAR ;

                       CAR ;

                       CDR ;

                       MUL ;

                       EDIV ;

                       IF_NONE { PUSH int 81 ; FAILWITH } {} ;

                       CAR ;

                       EDIV ;