parameter (or

            (or (or (nat %bailout) (or (unit %default) (nat %deposit)))

                (or (lambda %execute unit (list operation))

                    (or (nat %internal_bailout) (nat %internal_deposit))))

            (or

              (or (unit %internal_withdraw)

                  (or

                    (pair %remove_administrator (address %administrator_to_remove)

                                                (nat %token_id))

                    (pair %set_administrator (address %administrator_to_set)

                                             (nat %token_id))))

              (or

                (list %set_balance (pair (pair %request (address %owner) (nat %token_id))

                                        (nat %balance)))

                (or

                  (pair %set_vesting_contract (address %contract)

                                              (nat %duration_in_seconds))

                  (unit %withdraw)))));

storage (pair

          (pair

            (pair (big_map %administrators (pair (address %owner) (nat %token_id)) unit)

                  (pair (nat %current_balance) (nat %disc_factor)))

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

                  (pair (address %engine_address) (nat %last_balance))))

          (pair

            (pair (address %sender)

                  (pair (big_map %stakes address nat) (address %token_address)))

            (pair (pair (nat %token_id) (nat %total_stake))

                  (pair (address %vesting_contract) (nat %vesting_duration_in_seconds)))));

code { LAMBDA

         (pair unit

               (pair

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

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

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

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

         (pair (list operation)

               (pair unit

                     (pair

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

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

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

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

         { NIL operation ;

           SWAP ;

           CDR ;

           DUP ;

           DUG 2 ;

           CAR ;

           GET 5 ;

           CONTRACT %update unit ;

           IF_NONE { PUSH int 113 ; FAILWITH } {} ;

           PUSH mutez 0 ;

           UNIT ;

           TRANSFER_TOKENS ;

           CONS ;

           SWAP ;

           DUP ;

           DUG 2 ;

           GET 3 ;

           GET 4 ;

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

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

           IF_NONE { PUSH int 63 ; FAILWITH } {} ;

           PUSH mutez 0 ;

           SELF_ADDRESS ;

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

           IF_NONE { PUSH int 65 ; FAILWITH } {} ;

           NIL (pair address nat) ;

           DUP 6 ;

           GET 5 ;

           CAR ;

           SELF_ADDRESS ;

           PAIR ;

           CONS ;

           PAIR ;

           TRANSFER_TOKENS ;

           CONS ;

           SWAP ;

           UNIT ;

           DIG 2 ;

           PAIR 3 } ;

       SWAP ;

       LAMBDA

         (pair unit

               (pair

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

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

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

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

         (pair (list operation)

               (pair unit

                     (pair

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

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

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

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

         { NIL operation ;

           SWAP ;

           CDR ;

           DUP ;

           GET 5 ;

           CDR ;

           PUSH nat 0 ;

           COMPARE ;

           LT ;

           IF

             { DUP ;

               UNPAIR ;

               UNPAIR ;

               UNPAIR ;

               SWAP ;

               UNPAIR ;

               SWAP ;

               DUP 6 ;

               GET 5 ;

               CDR ;

               PUSH nat 1000000000000 ;

               DIG 7 ;

               DUP ;

               CAR ;

               GET 6 ;

               SWAP ;

               CAR ;

               CAR ;

               GET 3 ;

               SUB ;

               ISNAT ;

               IF_NONE { PUSH int 92 ; FAILWITH } {} ;

               MUL ;

               EDIV ;

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

               ADD ;

               SWAP ;

               PAIR ;

               SWAP ;

               PAIR ;

               PAIR ;

               PAIR ;

               DUP ;

               UNPAIR ;

               UNPAIR ;

               SWAP ;

               UNPAIR ;

               SWAP ;

               CAR ;

               DIG 4 ;

               CAR ;

               CAR ;

               GET 3 ;

               SWAP ;

               PAIR ;

               SWAP ;

               PAIR ;

               SWAP ;

               PAIR ;

               PAIR }

             {} ;

           UNIT ;

           DIG 2 ;

           PAIR 3 } ;

       SWAP ;

       LAMBDA

         (pair unit

               (pair

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

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

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

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

         (pair (list operation)

               (pair unit

                     (pair

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

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

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

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

         { NIL operation ;

           SWAP ;

           CDR ;

           SELF_ADDRESS ;

           SENDER ;

           COMPARE ;

           EQ ;

           IF {} { PUSH int 400 ; FAILWITH } ;

           UNIT ;

           DIG 2 ;

           PAIR 3 } ;

       SWAP ;

       LAMBDA

         (pair nat

               (pair

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

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

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

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

         (pair (list operation)

               (pair unit

                     (pair

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

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

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

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

         { NIL operation ;

           SWAP ;

           DUP ;

           DUG 2 ;

           CDR ;

           DUP ;

           CAR ;

           CAR ;

           CAR ;

           DIG 3 ;

           CAR ;

           SENDER ;

           PAIR ;

           MEM ;

           IF {} { PUSH int 401 ; FAILWITH } ;

           UNIT ;

           DIG 2 ;

           PAIR 3 } ;

       SWAP ;

       UNPAIR ;

       IF_LEFT

         { IF_LEFT

             { IF_LEFT

                 { DIG 2 ;

                   DROP ;

                   DIG 2 ;

                   DROP ;

                   DIG 2 ;

                   DROP ;

                   SWAP ;

                   UNPAIR ;

                   SWAP ;

                   UNPAIR ;

                   CDR ;

                   SENDER ;

                   PAIR ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   SWAP ;

                   DUG 2 ;

                   UNIT ;

                   PAIR ;

                   EXEC ;

                   DUP ;

                   GET 4 ;

                   DUG 2 ;

                   CAR ;

                   SELF %internal_bailout ;

                   PUSH mutez 0 ;

                   DIG 3 ;

                   TRANSFER_TOKENS ;

                   CONS }

                 { IF_LEFT

                     { DROP ;

                       SWAP ;

                       DROP ;

                       SWAP ;

                       DROP ;

                       SWAP ;

                       DROP ;

                       SWAP ;

                       DROP ;

                       DUP ;

                       UNPAIR ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       UNPAIR ;

                       DIG 5 ;

                       GET 5 ;

                       CDR ;

                       PUSH nat 1000000000000 ;

                       PUSH mutez 1 ;

                       AMOUNT ;

                       EDIV ;

                       IF_NONE { UNIT ; FAILWITH } {} ;

                       CAR ;

                       MUL ;

                       EDIV ;

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

                       ADD ;

                       PAIR ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       PAIR ;

                       NIL operation }

                     { DIG 2 ;

                       DROP ;

                       DIG 2 ;

                       DROP ;

                       DIG 2 ;

                       DROP ;

                       SWAP ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       CDR ;

                       SENDER ;

                       PAIR ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       DUG 2 ;

                       UNIT ;

                       PAIR ;

                       EXEC ;

                       DUP ;

                       GET 4 ;

                       DUG 2 ;

                       CAR ;

                       SELF %internal_deposit ;

                       PUSH mutez 0 ;

                       DIG 3 ;

                       TRANSFER_TOKENS ;

                       CONS } } }

             { IF_LEFT

                 { DIG 3 ;

                   DROP ;

                   DIG 3 ;

                   DROP ;

                   DIG 3 ;

                   DROP ;

                   DUG 2 ;

                   PUSH nat 0 ;

                   PAIR ;

                   EXEC ;

                   DUP ;

                   GET 4 ;

                   DUG 2 ;

                   CAR ;

                   SWAP ;

                   UNIT ;

                   EXEC ;

                   NIL operation ;

                   SWAP ;

                   ITER { CONS } ;

                   ITER { CONS } }

                 { IF_LEFT

                     { DIG 2 ;

                       DROP ;

                       DIG 3 ;

                       DROP ;

                       DIG 3 ;

                       DROP ;

                       DUG 2 ;

                       UNIT ;

                       PAIR ;

                       EXEC ;

                       DUP ;

                       GET 4 ;

                       DUG 2 ;

                       CAR ;

                       DIG 2 ;

                       DUP ;

                       CAR ;

                       GET 5 ;

                       SWAP ;

                       DUP ;

                       DUG 4 ;

                       GET 3 ;

                       CAR ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH int 401 ; FAILWITH } ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       DUP 4 ;

                       CAR ;

                       GET 6 ;

                       COMPARE ;

                       GE ;

                       IF {} { PUSH int 601 ; FAILWITH } ;

                       DUP 3 ;

                       UNPAIR ;

                       UNPAIR ;

                       UNPAIR ;

                       SWAP ;

                       CAR ;

                       DUP 7 ;

                       GET 5 ;

                       CDR ;

                       PUSH nat 1000000000000 ;

                       DUP 8 ;

                       DIG 9 ;

                       CAR ;

                       GET 6 ;

                       SUB ;

                       ISNAT ;

                       IF_NONE { PUSH int 256 ; FAILWITH } {} ;

                       MUL ;

                       EDIV ;

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

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       PAIR ;

                       PAIR ;

                       DUP ;

                       DUG 3 ;

                       UNPAIR ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       SWAP ;

                       CAR ;

                       DIG 5 ;

                       DIG 6 ;

                       CAR ;

                       GET 6 ;

                       SUB ;

                       ISNAT ;

                       IF_NONE { PUSH int 257 ; FAILWITH } {} ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       PAIR ;

                       SWAP }

                     { DUP 4 ;

                       DIG 2 ;

                       UNIT ;

                       PAIR ;

                       EXEC ;

                       DUP ;

                       GET 4 ;

                       DUG 2 ;

                       DUP ;

                       CAR ;

                       DUP 7 ;

                       DIG 4 ;

                       UNIT ;

                       PAIR ;

                       EXEC ;

                       DUP ;

                       GET 4 ;

                       DUG 4 ;

                       DUP ;

                       CAR ;

                       NIL operation ;

                       SWAP ;

                       ITER { CONS } ;

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

                       DROP ;

                       SWAP ;

                       DROP ;

                       DIG 3 ;

                       DROP ;

                       DIG 3 ;

                       DROP ;

                       DIG 3 ;

                       DROP ;

                       DIG 3 ;

                       DROP ;

                       DUP 3 ;

                       GET 3 ;

                       GET 4 ;

                       CONTRACT %transfer (list (pair address

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

                       IF_NONE { PUSH int 35 ; FAILWITH } {} ;

                       PUSH mutez 0 ;

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

                       NIL (pair address (pair nat nat)) ;

                       DUP 6 ;

                       DUP 8 ;

                       GET 5 ;

                       CAR ;

                       SELF_ADDRESS ;

                       PAIR 3 ;

                       CONS ;

                       DUP 7 ;

                       GET 3 ;

                       CAR ;

                       PAIR ;

                       CONS ;

                       TRANSFER_TOKENS ;

                       CONS ;

                       DUP 3 ;

                       CAR ;

                       CAR ;

                       GET 4 ;

                       PUSH nat 1000000000000 ;

                       DUP 4 ;

                       MUL ;

                       EDIV ;

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

                       DIG 3 ;

                       DUP ;

                       CAR ;

                       GET 3 ;

                       CDR ;

                       SWAP ;

                       DUP ;

                       DUG 5 ;

                       GET 3 ;

                       CAR ;

                       MEM ;

                       IF

                         { DIG 3 ;

                           DUP ;

                           CAR ;

                           GET 3 ;

                           CAR ;

                           SWAP ;

                           DUP ;

                           CAR ;

                           GET 3 ;

                           CDR ;

                           SWAP ;

                           DUP ;

                           DUG 6 ;

                           GET 3 ;

                           CAR ;

                           GET ;

                           IF_NONE { PUSH int 152 ; FAILWITH } {} ;

                           COMPARE ;

                           LT }

                         { PUSH bool False } ;

                       IF

                         { PUSH nat 0 ;

                           PUSH nat 1000000000000 ;

                           DIG 5 ;

                           DUP ;

                           CAR ;

                           GET 3 ;

                           CDR ;

                           SWAP ;

                           DUP ;

                           DUG 7 ;

                           GET 3 ;

                           CAR ;

                           GET ;

                           IF_NONE { PUSH int 153 ; FAILWITH } {} ;

                           DUP 7 ;

                           CAR ;

                           GET 3 ;

                           CAR ;

                           SUB ;

                           ISNAT ;

                           IF_NONE { PUSH int 153 ; FAILWITH } {} ;

                           DIG 6 ;

                           DUP ;

                           GET 3 ;

                           GET 3 ;

                           SWAP ;

                           DUP ;

                           DUG 8 ;

                           GET 3 ;

                           CAR ;

                           GET ;

                           IF_NONE { PUSH int 153 ; FAILWITH } {} ;

                           MUL ;

                           EDIV ;

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

                           COMPARE ;

                           GT ;

                           IF

                             { SWAP ;

                               DUP 4 ;

                               GET 3 ;

                               CAR ;

                               CONTRACT unit ;

                               IF_NONE { PUSH int 155 ; FAILWITH } {} ;

                               PUSH mutez 1 ;

                               PUSH nat 1000000000000 ;

                               DIG 6 ;

                               DUP ;

                               CAR ;

                               GET 3 ;

                               CDR ;

                               SWAP ;

                               DUP ;

                               DUG 8 ;

                               GET 3 ;

                               CAR ;

                               GET ;

                               IF_NONE { PUSH int 153 ; FAILWITH } {} ;

                               DUP 8 ;

                               CAR ;

                               GET 3 ;

                               CAR ;

                               SUB ;

                               ISNAT ;

                               IF_NONE { PUSH int 153 ; FAILWITH } {} ;

                               DIG 7 ;

                               DUP ;

                               GET 3 ;

                               GET 3 ;

                               SWAP ;

                               DUP ;

                               DUG 9 ;

                               GET 3 ;

                               CAR ;

                               GET ;

                               IF_NONE { PUSH int 153 ; FAILWITH } {} ;

                               MUL ;

                               EDIV ;

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

                               MUL ;

                               UNIT ;

                               TRANSFER_TOKENS ;

                               CONS ;

                               SWAP }

                             {} }

                         {} ;

                       DIG 3 ;

                       DUP ;

                       GET 3 ;

                       GET 3 ;

                       SWAP ;

                       DUP ;

                       DUG 5 ;

                       GET 3 ;

                       CAR ;

                       MEM ;

                       IF

                         { DUP 4 ;

                           UNPAIR ;

                           SWAP ;

                           UNPAIR ;

                           UNPAIR ;

                           SWAP ;

                           UNPAIR ;

                           DUP ;

                           DIG 9 ;

                           GET 3 ;

                           CAR ;

                           DUP ;

                           DUG 2 ;

                           GET ;

                           IF_NONE { PUSH int 157 ; FAILWITH } {} ;

                           DUP 8 ;

                           ADD ;

                           SOME ;

                           SWAP ;

                           UPDATE ;

                           PAIR ;

                           SWAP ;

                           PAIR ;

                           PAIR ;

                           SWAP ;

                           PAIR ;

                           DUG 3 }

                         { DUP 4 ;

                           UNPAIR ;

                           SWAP ;

                           UNPAIR ;

                           UNPAIR ;

                           SWAP ;

                           UNPAIR ;

                           DUP 6 ;

                           SOME ;

                           DIG 9 ;

                           GET 3 ;

                           CAR ;

                           UPDATE ;

                           PAIR ;

                           SWAP ;

                           PAIR ;

                           PAIR ;

                           SWAP ;

                           PAIR ;

                           DUG 3 } ;

                       DUP 4 ;

                       UNPAIR ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       UNPAIR ;

                       SWAP ;

                       DUP 9 ;

                       CAR ;

                       GET 3 ;

                       CAR ;

                       SOME ;

                       DIG 9 ;

                       GET 3 ;

                       CAR ;

                       UPDATE ;

                       SWAP ;

                       PAIR ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       UNPAIR ;

                       SWAP ;

                       DIG 5 ;

                       ADD ;

                       SWAP ;

                       PAIR ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       SWAP ;

                       DIG 6 ;

                       ADD ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       PAIR ;

                       SWAP } } } }

         { IF_LEFT

             { IF_LEFT

                 { DUP 4 ;

                   DIG 2 ;

                   UNIT ;

                   PAIR ;

                   EXEC ;

                   DUP ;

                   GET 4 ;

                   DUG 2 ;

                   DUP ;

                   CAR ;

                   PUSH address "tz1RKmJwoAiaqFdjQYSbFy1j7u7UhEFsqXq7" ;

                   DUP 5 ;

                   GET 7 ;

                   COMPARE ;

                   NEQ ;

                   IF {} { PUSH int 804 ; FAILWITH } ;

                   DUP 7 ;

                   DIG 4 ;

                   UNIT ;

                   PAIR ;

                   EXEC ;

                   DUP ;

                   GET 4 ;

                   DUG 4 ;

                   DUP ;

                   CAR ;

                   NIL operation ;

                   SWAP ;

                   ITER { CONS } ;

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

                   DROP ;

                   SWAP ;

                   DROP ;

                   SWAP ;

                   DROP ;

                   DIG 2 ;

                   DROP ;

                   DIG 2 ;

                   DROP ;

                   DIG 2 ;

                   DROP ;

                   DIG 2 ;

                   DROP ;

                   PUSH nat 1000000000000 ;

                   DIG 2 ;

                   DUP ;

                   CAR ;

                   CAR ;

                   GET 4 ;

                   SWAP ;

                   DUP ;

                   GET 3 ;

                   GET 3 ;

                   SWAP ;

                   DUP ;

                   DUG 5 ;

                   GET 3 ;

                   CAR ;

                   GET ;

                   IF_NONE { PUSH int 196 ; FAILWITH } {} ;

                   MUL ;

                   EDIV ;

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

                   NOW ;

                   DUP 4 ;

                   GET 8 ;

                   INT ;

                   ADD ;

                   DIG 2 ;

                   DUP 4 ;

                   GET 7 ;

                   CONTRACT %vest (list (pair address (pair nat timestamp))) ;

                   IF_NONE { PUSH int 199 ; FAILWITH } {} ;