{ parameter (or

              (list %configure (or (address %update_administrator)

                                  (or (nat %update_current_snapshot)

                                      (or (nat %update_history_length)

                                          (or (nat %update_minimum_endorsements)

                                              (or (nat %update_snapshot_interval)

                                                  (set %update_validators (or

                                                                           (address %add)

                                                                           (address %remove)))))))))

              (pair %submit_block_state_root (nat %block_number) (bytes %state_root))) ;

  storage (pair

            (pair

              (pair %config (pair (address %administrator) (nat %history_length))

                            (pair (nat %minimum_endorsements)

                                  (pair (nat %snapshot_interval)

                                        (set %validators address))))

              (nat %current_snapshot))

            (pair (set %history nat) (big_map %state_root nat (map address bytes)))) ;

  code { UNPAIR ;

         IF_LEFT

           { SENDER ;

             DUP 3 ;

             CAR ;

             CAR ;

             CAR ;

             CAR ;

             COMPARE ;

             EQ ;

             IF {} { PUSH string "NOT_ADMINISTRATOR" ; FAILWITH } ;

             DUP ;

             ITER { DUP ;

                    IF_LEFT

                      { SWAP ; DROP ; DIG 2 ; UNPAIR ; UNPAIR ; UNPAIR ; CDR ; DIG 4 ; PAIR ; PAIR ; PAIR ; PAIR ; SWAP }

                      { IF_LEFT

                          { SWAP ; DROP ; DIG 2 ; UNPAIR ; CAR ; DIG 2 ; SWAP ; PAIR ; PAIR ; SWAP }

                          { IF_LEFT

                              { SWAP ;

                                DROP ;

                                DIG 2 ;

                                UNPAIR ;

                                UNPAIR ;

                                UNPAIR ;

                                CAR ;

                                DIG 4 ;

                                SWAP ;

                                PAIR ;

                                PAIR ;

                                PAIR ;

                                PAIR ;

                                SWAP }

                              { IF_LEFT

                                  { SWAP ;

                                    DROP ;

                                    DIG 2 ;

                                    UNPAIR ;

                                    UNPAIR ;

                                    DIG 3 ;

                                    UPDATE 3 ;

                                    PAIR ;

                                    PAIR ;

                                    SWAP }

                                  { IF_LEFT

                                      { SWAP ;

                                        DROP ;

                                        DIG 2 ;

                                        UNPAIR ;

                                        UNPAIR ;

                                        DIG 3 ;

                                        UPDATE 5 ;

                                        PAIR ;

                                        PAIR ;

                                        SWAP }

                                      { DUP ;

                                        ITER { IF_LEFT

                                                 { DIG 4 ;

                                                   UNPAIR ;

                                                   UNPAIR ;

                                                   DUP ;

                                                   GET 6 ;

                                                   PUSH bool True ;

                                                   DIG 5 ;

                                                   UPDATE ;

                                                   UPDATE 6 ;

                                                   PAIR ;

                                                   PAIR ;

                                                   DUG 3 }

                                                 { DIG 4 ;

                                                   UNPAIR ;

                                                   UNPAIR ;

                                                   DUP ;

                                                   GET 6 ;

                                                   PUSH bool False ;

                                                   DIG 5 ;

                                                   UPDATE ;

                                                   UPDATE 6 ;

                                                   PAIR ;

                                                   PAIR ;

                                                   DUG 3 } } ;

                                        DROP 2 } } } } } } ;

             DROP }

           { DUP ;

             UNPAIR ;

             DUP 4 ;

             CAR ;

             CAR ;

             GET 6 ;

             SENDER ;

             MEM ;

             IF {} { PUSH string "NOT_VALIDATOR" ; FAILWITH } ;

             PUSH nat 0 ;

             DUP 5 ;

             CAR ;

             CDR ;

             COMPARE ;

             EQ ;

             IF

               { DIG 3 ; UNPAIR ; CAR ; DUP 3 ; SWAP ; PAIR ; PAIR ; DUG 3 }

               { DUP ;

                 DUP 5 ;

                 CAR ;

                 CDR ;

                 COMPARE ;

                 EQ ;

                 IF {} { PUSH string "INVALID_SNAPSHOT" ; FAILWITH } } ;

             DUP 4 ;

             GET 4 ;

             SWAP ;

             DUP ;

             DUG 2 ;

             MEM ;

             IF

               { DIG 3 ;

                 DUP ;

                 GET 4 ;

                 DUP ;

                 DUP 4 ;

                 DUP ;

                 DUG 2 ;

                 GET ;

                 IF_NONE { PUSH int 444 ; FAILWITH } {} ;

                 DUP 6 ;

                 SOME ;

                 SENDER ;

                 UPDATE ;

                 SOME ;

                 SWAP ;

                 UPDATE ;

                 UPDATE 4 ;

                 DUG 3 }

               { DIG 3 ;

                 DUP ;

                 GET 4 ;

                 EMPTY_MAP address bytes ;

                 DUP 5 ;

                 SOME ;

                 SENDER ;

                 UPDATE ;

                 SOME ;

                 DUP 4 ;

                 UPDATE ;

                 UPDATE 4 ;

                 DUG 3 } ;

             DUP 4 ;

             GET 4 ;

             SWAP ;

             DUP ;

             DUG 2 ;

             GET ;

             IF_NONE { PUSH string "UNPROCESSED_BLOCK_STATE" ; FAILWITH } {} ;

             LAMBDA

               (pair nat (map address bytes))

               (option bytes)

               { DUP ;

                 UNPAIR ;

                 EMPTY_MAP bytes nat ;

                 DUP 3 ;

                 ITER { SWAP ;

                        DUP ;

                        DUG 2 ;

                        PUSH nat 1 ;

                        DIG 3 ;

                        DUP 4 ;

                        CDR ;

                        GET ;

                        IF_NONE { PUSH nat 0 } {} ;

                        ADD ;

                        SOME ;

                        DIG 2 ;

                        CDR ;

                        UPDATE } ;

                 DUP ;

                 PUSH bytes 0x ;

                 SWAP ;

                 ITER { CAR ;

                        DUP 3 ;

                        DUP 3 ;

                        GET ;

                        IF_NONE { PUSH nat 0 } {} ;

                        DUP 4 ;

                        DUP 3 ;

                        GET ;

                        IF_NONE { PUSH int 106 ; FAILWITH } {} ;

                        COMPARE ;

                        GT ;

                        IF { SWAP ; DROP } { DROP } } ;

                 PUSH nat 0 ;

                 DUP 3 ;

                 SIZE ;

                 COMPARE ;

                 EQ ;

                 IF

                   { SWAP ; DROP ; SWAP ; DROP ; SWAP ; DROP ; SWAP ; DROP ; PUSH bool True }

                   { DIG 3 ;

                     DROP ;

                     DIG 3 ;

                     DROP ;

                     DUP ;

                     DUG 3 ;

                     GET ;

                     IF_NONE { PUSH int 113 ; FAILWITH } {} ;

                     COMPARE ;

                     LT } ;

                 IF { DROP ; NONE bytes } { SOME } } ;

             SWAP ;

             DUP 6 ;

             CAR ;

             CAR ;

             GET 3 ;

             PAIR ;

             EXEC ;

             IF_NONE

               { DROP 3 }

               { DROP ;

                 DUP 4 ;

                 UNPAIR ;

                 UNPAIR ;

                 SWAP ;

                 DIG 6 ;

                 CAR ;

                 CAR ;

                 GET 5 ;

                 ADD ;

                 SWAP ;

                 PAIR ;

                 PAIR ;

                 DUP ;

                 GET 3 ;

                 PUSH bool True ;

                 DUP 4 ;

                 UPDATE ;

                 UPDATE 3 ;

                 DUP ;

                 CAR ;

                 CAR ;

                 CAR ;

                 CDR ;

                 SWAP ;

                 DUP ;

                 DUG 5 ;

                 GET 3 ;

                 SIZE ;

                 COMPARE ;

                 GT ;

                 IF

                   { SWAP ;

                     DROP ;

                     SWAP ;

                     DROP ;

                     SWAP ;

                     DUP ;

                     DUG 2 ;

                     GET 3 ;

                     ITER { SWAP ;

                            DUP ;

                            DUG 2 ;

                            SWAP ;

                            DUP ;

                            DUG 2 ;

                            COMPARE ;

                            LT ;

                            IF { SWAP ; DROP } { DROP } } ;

                     SWAP ;

                     DUP ;

                     GET 4 ;

                     NONE (map address bytes) ;

                     DUP 4 ;

                     UPDATE ;

                     UPDATE 4 ;

                     DUP ;

                     GET 3 ;

                     PUSH bool False ;

                     DIG 3 ;

                     UPDATE ;

                     UPDATE 3 }

                   { DROP 3 } } } ;

         NIL operation ;

         PAIR } ;

  view "validate_storage_proof"

        (pair (bytes %account)

              (pair (bytes %account_proof_rlp)

                    (pair (nat %block_number)

                          (pair (bytes %storage_proof_rlp) (bytes %storage_slot)))))

        bytes

        { UNPAIR ;

          DUP ;

          UNPAIR 5 ;

          LAMBDA

            (pair bytes

                  (pair bytes

                        (pair

                          (pair (lambda bytes bool)

                                (pair (lambda bytes bytes)

                                      (lambda bytes (map nat bytes))))

                          bytes)))

            bytes

            { DUP ;

              UNPAIR 4 ;

              LAMBDA

                (pair bytes nat)

                bytes

                { DUP ;

                  UNPAIR ;

                  DUP ;

                  SIZE ;

                  LAMBDA

                    bytes

                    nat

                    { DUP ;

                      SIZE ;

                      DUP ;

                      PUSH nat 0 ;

                      SWAP ;

                      PUSH nat 0 ;

                      DUP ;

                      DUP 3 ;

                      COMPARE ;

                      GT ;

                      LOOP { DUP 5 ;

                             PUSH nat 1 ;

                             DUP 3 ;

                             SLICE ;

                             IF_NONE { PUSH int 126 ; FAILWITH } {} ;

                             PUSH nat 2 ;

                             PUSH nat 1 ;

                             DUP 4 ;

                             ADD ;

                             DUP 7 ;

                             SUB ;

                             ISNAT ;

                             IF_NONE { PUSH int 127 ; FAILWITH } {} ;

                             MUL ;

                             PUSH nat 1 ;

                             PUSH nat 16 ;

                             DUP 3 ;

                             DUP ;

                             PUSH nat 0 ;

                             COMPARE ;

                             NEQ ;

                             LOOP { PUSH nat 0 ;

                                    PUSH nat 2 ;

                                    DUP 3 ;

                                    EDIV ;

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

                                    COMPARE ;

                                    NEQ ;

                                    IF { SWAP ; DUP ; DUG 2 ; DIG 3 ; MUL ; DUG 2 } {} ;

                                    PUSH nat 1 ;

                                    SWAP ;

                                    LSR ;

                                    SWAP ;

                                    DUP ;

                                    MUL ;

                                    SWAP ;

                                    DUP ;

                                    PUSH nat 0 ;

                                    COMPARE ;

                                    NEQ } ;

                             DROP 2 ;

                             SWAP ;

                             DROP ;

                             PUSH bytes 0x00000000000000000000000000000000000000000000000000000000000000 ;

                             DIG 2 ;

                             PUSH bytes 0x050a00000020 ;

                             CONCAT ;

                             CONCAT ;

                             UNPACK bls12_381_fr ;

                             IF_NONE { PUSH int 134 ; FAILWITH } {} ;

                             INT ;

                             ISNAT ;

                             IF_NONE { PUSH int 133 ; FAILWITH } {} ;

                             MUL ;

                             DIG 3 ;

                             ADD ;

                             DUG 2 ;

                             PUSH nat 1 ;

                             ADD ;

                             DUP ;

                             DUP 3 ;

                             COMPARE ;

                             GT } ;

                      DROP 2 ;

                      SWAP ;

                      DROP ;

                      SWAP ;

                      DROP } ;

                  SWAP ;

                  DUP ;

                  PUSH nat 0 ;

                  COMPARE ;

                  LT ;

                  IF {} { PUSH string "Empty bytes array" ; FAILWITH } ;

                  DUP ;

                  PUSH nat 2 ;

                  SWAP ;

                  MUL ;

                  DUP 5 ;

                  SWAP ;

                  DUP ;

                  DUG 2 ;

                  COMPARE ;

                  GE ;

                  IF {} { PUSH string "Skip nibbles amount too large" ; FAILWITH } ;

                  DUP ;

                  PUSH bytes 0x ;

                  SWAP ;

                  DUP 7 ;

                  DUP ;

                  DUP 3 ;

                  COMPARE ;

                  GT ;

                  LOOP { DUP 6 ;

                         DUP 8 ;

                         PUSH nat 1 ;

                         PUSH nat 2 ;

                         DUP 5 ;

                         EDIV ;

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

                         SLICE ;

                         IF_NONE { PUSH int 143 ; FAILWITH } {} ;

                         EXEC ;

                         PUSH nat 15 ;

                         PUSH (map nat nat) { Elt 0 4 ; Elt 1 0 } ;

                         PUSH nat 2 ;

                         DUP 5 ;

                         EDIV ;

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

                         GET ;

                         IF_NONE { PUSH int 147 ; FAILWITH } {} ;

                         DIG 2 ;

                         LSR ;

                         AND ;

                         PACK ;

                         PUSH nat 1 ;

                         PUSH nat 2 ;

                         SLICE ;

                         IF_NONE { PUSH int 148 ; FAILWITH } {} ;

                         DIG 3 ;

                         CONCAT ;

                         DUG 2 ;

                         PUSH nat 1 ;

                         ADD ;

                         DUP ;

                         DUP 3 ;

                         COMPARE ;

                         GT } ;

                  DROP 2 ;

                  SWAP ;

                  DROP ;

                  SWAP ;

                  DROP ;

                  SWAP ;

                  DROP ;

                  SWAP ;

                  DROP ;

                  SWAP ;

                  DROP ;

                  SWAP ;

                  DROP } ;

              LAMBDA

                (pair bytes (pair bytes nat))

                nat

                { DUP ;

                  UNPAIR 3 ;

                  PUSH nat 0 ;

                  PUSH bool True ;

                  DUP 3 ;

                  SIZE ;

                  DUP 5 ;

                  SIZE ;

                  DUP 3 ;

                  IF

                    { SWAP ; DUP ; DUG 2 ; DUP 8 ; DUP 6 ; ADD ; COMPARE ; LT }

                    { PUSH bool False } ;

                  IF { DUP ; DUP 5 ; COMPARE ; LT } { PUSH bool False } ;

                  LOOP { DUP 6 ;

                         PUSH nat 1 ;

                         DUP 6 ;

                         SLICE ;

                         IF_NONE { PUSH int 173 ; FAILWITH } {} ;

                         DUP 6 ;

                         PUSH nat 1 ;

                         DUP 10 ;

                         DUP 8 ;

                         ADD ;

                         SLICE ;

                         IF_NONE { PUSH int 172 ; FAILWITH } {} ;

                         COMPARE ;

                         NEQ ;

                         IF

                           { DIG 2 ; DROP ; PUSH bool False ; DUG 2 }

                           { PUSH nat 1 ; DIG 4 ; ADD ; DUG 3 } ;

                         DUP 3 ;

                         IF

                           { SWAP ; DUP ; DUG 2 ; DUP 8 ; DUP 6 ; ADD ; COMPARE ; LT }

                           { PUSH bool False } ;

                         IF { DUP ; DUP 5 ; COMPARE ; LT } { PUSH bool False } } ;

                  DROP 3 ;

                  SWAP ;

                  DROP ;

                  SWAP ;

                  DROP ;

                  SWAP ;

                  DROP ;

                  SWAP ;

                  DROP } ;

              LAMBDA

                bytes

                bytes

                { DUP ;

                  SIZE ;

                  PUSH nat 0 ;

                  COMPARE ;

                  LT ;

                  IF {} { PUSH string "Empty bytes array" ; FAILWITH } ;

                  LAMBDA

                    bytes

                    nat

                    { DUP ;

                      SIZE ;

                      DUP ;

                      PUSH nat 0 ;

                      SWAP ;

                      PUSH nat 0 ;

                      DUP ;

                      DUP 3 ;

                      COMPARE ;

                      GT ;

                      LOOP { DUP 5 ;

                             PUSH nat 1 ;

                             DUP 3 ;

                             SLICE ;

                             IF_NONE { PUSH int 126 ; FAILWITH } {} ;

                             PUSH nat 2 ;

                             PUSH nat 1 ;

                             DUP 4 ;

                             ADD ;

                             DUP 7 ;

                             SUB ;

                             ISNAT ;

                             IF_NONE { PUSH int 127 ; FAILWITH } {} ;

                             MUL ;

                             PUSH nat 1 ;

                             PUSH nat 16 ;

                             DUP 3 ;

                             DUP ;

                             PUSH nat 0 ;

                             COMPARE ;

                             NEQ ;

                             LOOP { PUSH nat 0 ;

                                    PUSH nat 2 ;

                                    DUP 3 ;

                                    EDIV ;

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

                                    COMPARE ;

                                    NEQ ;

                                    IF { SWAP ; DUP ; DUG 2 ; DIG 3 ; MUL ; DUG 2 } {} ;

                                    PUSH nat 1 ;

                                    SWAP ;

                                    LSR ;

                                    SWAP ;

                                    DUP ;

                                    MUL ;

                                    SWAP ;

                                    DUP ;

                                    PUSH nat 0 ;

                                    COMPARE ;

                                    NEQ } ;

                             DROP 2 ;

                             SWAP ;

                             DROP ;

                             PUSH bytes 0x00000000000000000000000000000000000000000000000000000000000000 ;

                             DIG 2 ;

                             PUSH bytes 0x050a00000020 ;

                             CONCAT ;

                             CONCAT ;

                             UNPACK bls12_381_fr ;

                             IF_NONE { PUSH int 134 ; FAILWITH } {} ;

                             INT ;

                             ISNAT ;

                             IF_NONE { PUSH int 133 ; FAILWITH } {} ;

                             MUL ;

                             DIG 3 ;

                             ADD ;

                             DUG 2 ;

                             PUSH nat 1 ;

                             ADD ;

                             DUP ;

                             DUP 3 ;

                             COMPARE ;

                             GT } ;

                      DROP 2 ;

                      SWAP ;

                      DROP ;

                      SWAP ;

                      DROP } ;

                  DUP ;

                  LAMBDA

                    (pair bytes nat)

                    bytes

                    { DUP ;

                      UNPAIR ;

                      DUP ;

                      SIZE ;

                      LAMBDA

                        bytes

                        nat

                        { DUP ;

                          SIZE ;

                          DUP ;

                          PUSH nat 0 ;

                          SWAP ;

                          PUSH nat 0 ;

                          DUP ;

                          DUP 3 ;

                          COMPARE ;

                          GT ;

                          LOOP { DUP 5 ;

                                 PUSH nat 1 ;

                                 DUP 3 ;

                                 SLICE ;

                                 IF_NONE { PUSH int 126 ; FAILWITH } {} ;

                                 PUSH nat 2 ;

                                 PUSH nat 1 ;

                                 DUP 4 ;

                                 ADD ;

                                 DUP 7 ;

                                 SUB ;

                                 ISNAT ;

                                 IF_NONE { PUSH int 127 ; FAILWITH } {} ;

                                 MUL ;

                                 PUSH nat 1 ;

                                 PUSH nat 16 ;

                                 DUP 3 ;

                                 DUP ;

                                 PUSH nat 0 ;

                                 COMPARE ;

                                 NEQ ;

                                 LOOP { PUSH nat 0 ;

                                        PUSH nat 2 ;

                                        DUP 3 ;

                                        EDIV ;

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

                                        COMPARE ;

                                        NEQ ;

                                        IF

                                          { SWAP ; DUP ; DUG 2 ; DIG 3 ; MUL ; DUG 2 }

                                          {} ;

                                        PUSH nat 1 ;

                                        SWAP ;

                                        LSR ;

                                        SWAP ;

                                        DUP ;

                                        MUL ;

                                        SWAP ;

                                        DUP ;

                                        PUSH nat 0 ;

                                        COMPARE ;

                                        NEQ } ;

                                 DROP 2 ;

                                 SWAP ;

                                 DROP ;

                                 PUSH bytes 0x00000000000000000000000000000000000000000000000000000000000000 ;

                                 DIG 2 ;

                                 PUSH bytes 0x050a00000020 ;

                                 CONCAT ;

                                 CONCAT ;

                                 UNPACK bls12_381_fr ;

                                 IF_NONE { PUSH int 134 ; FAILWITH } {} ;

                                 INT ;

                                 ISNAT ;

                                 IF_NONE { PUSH int 133 ; FAILWITH } {} ;

                                 MUL ;

                                 DIG 3 ;

                                 ADD ;

                                 DUG 2 ;

                                 PUSH nat 1 ;

                                 ADD ;

                                 DUP ;

                                 DUP 3 ;

                                 COMPARE ;

                                 GT } ;

                          DROP 2 ;

                          SWAP ;

                          DROP ;

                          SWAP ;

                          DROP } ;

                      SWAP ;

                      DUP ;

                      PUSH nat 0 ;

                      COMPARE ;

                      LT ;

                      IF {} { PUSH string "Empty bytes array" ; FAILWITH } ;

                      DUP ;

                      PUSH nat 2 ;

                      SWAP ;

                      MUL ;

                      DUP 5 ;

                      SWAP ;

                      DUP ;

                      DUG 2 ;

                      COMPARE ;

                      GE ;

                      IF {} { PUSH string "Skip nibbles amount too large" ; FAILWITH } ;

                      DUP ;

                      PUSH bytes 0x ;

                      SWAP ;

                      DUP 7 ;

                      DUP ;

                      DUP 3 ;

                      COMPARE ;

                      GT ;

                      LOOP { DUP 6 ;

                             DUP 8 ;

                             PUSH nat 1 ;

                             PUSH nat 2 ;

                             DUP 5 ;

                             EDIV ;

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

                             SLICE ;

                             IF_NONE { PUSH int 143 ; FAILWITH } {} ;

                             EXEC ;

                             PUSH nat 15 ;

                             PUSH (map nat nat) { Elt 0 4 ; Elt 1 0 } ;

                             PUSH nat 2 ;

                             DUP 5 ;

                             EDIV ;

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

                             GET ;

                             IF_NONE { PUSH int 147 ; FAILWITH } {} ;

                             DIG 2 ;

                             LSR ;

                             AND ;

                             PACK ;

                             PUSH nat 1 ;

                             PUSH nat 2 ;

                             SLICE ;

                             IF_NONE { PUSH int 148 ; FAILWITH } {} ;

                             DIG 3 ;

                             CONCAT ;

                             DUG 2 ;

                             PUSH nat 1 ;

                             ADD ;

                             DUP ;

                             DUP 3 ;

                             COMPARE ;

                             GT } ;

                      DROP 2 ;

                      SWAP ;

                      DROP ;

                      SWAP ;

                      DROP ;

                      SWAP ;

                      DROP ;

                      SWAP ;

                      DROP ;

                      SWAP ;

                      DROP ;

                      SWAP ;

                      DROP } ;

                  SWAP ;

                  DUP 4 ;

                  PUSH nat 1 ;

                  PUSH nat 0 ;

                  SLICE ;

                  IF_NONE { PUSH int 188 ; FAILWITH } {} ;

                  EXEC ;

                  DUP ;

                  PUSH nat 4 ;

                  SWAP ;

                  LSR ;

                  PUSH nat 0 ;

                  DUP ;

                  DUP 3 ;

                  COMPARE ;

                  EQ ;

                  IF

                    { DROP 3 ; SWAP ; DROP ; PUSH nat 2 }