import { Bytes, Field, Provable, UInt32, UInt64, UInt8 } from 'o1js';
import { DynamicArray } from './dynamic-array.ts';
import { StaticArray } from './static-array.ts';
import { ProvableType } from '../o1js-missing.ts';
import type { Constructor } from '../types.ts';
export { DynamicSHA2, Sha2IterationState, Sha2Iteration, Sha2FinalIteration, State32, State64, Block32, Block64, Bytes28, Bytes32, Bytes48, Bytes64, };
declare const DynamicSHA2: {
    /**
     * Hash a dynamic-length byte array using different variants of SHA2.
     *
     * The first argument is the output length in bits (224, 256, 384, or 512).
     *
     * The input type `DynamicArray<UInt8>` is compatible with both `DynamicString` and `DynamicBytes`:
     *
     * ```ts
     * // using DynamicString
     * const String = DynamicString({ maxLength: 120 });
     * let string = String.from('hello');
     * let hash = DynamicSHA2.hash(256, string);
     *
     * // using DynamicBytes
     * const Bytes = DynamicBytes({ maxLength: 120 });
     * let bytes = Bytes.fromHex('010203');
     * let hash = DynamicSHA2.hash(256, bytes);
     * ```
     */
    hash: typeof sha2;
    /**
     * `DynamicSHA2.split()` is the first part of a more flexible API which allows to split proving a SHA2 hash over multiple proofs.
     *
     * Input arguments:
     * - `len`: the output length in bits (224, 256, 384, or 512)
     * - `blocksPerIteration`: how many SHA2 blocks (64-128 bytes) to process in each proof/iteration. Reasonable values are 2-8.
     * - `bytes`: the input bytes to hash
     *
     * `split()` is called **outside provable code** and prepares the inputs to the different proofs:
     * - `initial`: the initial "state" of the iteration (which is independent of the string to be hashed, and also returned by `Sha2IterationState.initial()`)
     * - `iterations`: a sequence of chunks (several blocks each) of the input string, to be passed to `update()`
     * - `final`: the last chunk of the input string, to be passed to `finalize()`
     *
     * Gist of how to use `split()`, `update()`, and `finalize()`:
     * ```ts
     * // outside the circuit:
     * const BLOCKS_PER_ITERATION = 6;
     * let { initial, iterations, final } = DynamicSHA2.split(256, BLOCKS_PER_ITERATION, bytes);
     *
     * // inside "update" circuit, for every iteration:
     * state = DynamicSHA2.update(initial, iterations[0]);
     * // OR
     * state = DynamicSHA2.update(state, iterations[i]);
     *
     * // inside "finalize" circuit:
     * let hash = DynamicSHA2.finalize(state, final, bytes);
     * ```
     */
    split: typeof split;
    /**
     * `update()` is the second part of the API for splitting a SHA2 hash proof.
     *
     * It takes the current `Sha2IterationState` and a `Sha2Iteration` (a chunk of blocks to be hashed) and returns the updated state.
     *
     * See `split()` for additional details.
     */
    update: typeof update;
    /**
     * `finalize()` is the last part of the API for splitting a SHA2 hash proof.
     *
     * It takes the current `Sha2IterationState`, a `Sha2FinalIteration`, and the original input bytes, and returns the hash.
     * Since the `Sha2IterationState` contains a commitment to the previous blocks that were hashed, calling `finalize()` is able
     * to prove that the same input bytes were hashed across multiple iterations. Thus, after calling it you are able to use
     * the same input bytes in further statements.
     *
     * See `split()` for additional details.
     */
    finalize: typeof finalize;
    padding256: typeof padding256;
    padding512: typeof padding512;
    commitBlock256: typeof commitBlock256;
    commitBlock512: typeof commitBlock512;
    hashBlock256: typeof hashBlock256;
    hashBlock512: typeof hashBlock512;
    initialState256: (l: 224 | 256) => {
        array: UInt32[];
        readonly innerType: Provable<UInt32, bigint>;
        readonly length: number;
        readonly maxLength: number;
        assertIndexInRange(i: UInt32 | number): void;
        get(i: UInt32 | number): UInt32;
        getOption(i: UInt32 | number): import("o1js").Option<UInt32>;
        getOrUnconstrained(i: Field): UInt32;
        set(i: UInt32 | number, value: UInt32): void;
        setOrDoNothing(i: Field, value: UInt32): void;
        map<S>(type: ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
        forEach(f: (t: UInt32, i: number) => void): void;
        reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
        chunk(chunkSize: number): {
            array: /*elided*/ any[];
            readonly innerType: Provable</*elided*/ any, bigint[]>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): /*elided*/ any;
            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
            getOrUnconstrained(i: Field): /*elided*/ any;
            set(i: UInt32 | number, value: /*elided*/ any): void;
            setOrDoNothing(i: Field, value: /*elided*/ any): void;
            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: /*elided*/ any, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[][]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                getOrUnconstrained(i: Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                    getOrUnconstrained(i: Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                        getOrUnconstrained(i: Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                            getOrUnconstrained(i: Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                getOrUnconstrained(i: Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                    getOrUnconstrained(i: Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                        getOrUnconstrained(i: Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                            getOrUnconstrained(i: Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                                getOrUnconstrained(i: Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): /*elided*/ any;
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<Field>;
                                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<Field>;
                                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<Field>;
                                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<Field>;
                                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<Field>;
                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<Field>;
                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<Field>;
                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<Field>;
                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<Field, import("o1js").Bool[]>;
                _indicesInRange: Set<Field>;
                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<Field, import("o1js").Bool[]>;
            _indicesInRange: Set<Field>;
            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[][];
            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
        };
        toReversed(): /*elided*/ any;
        slice(start: number, end: number): /*elided*/ any;
        _indexMasks: Map<Field, import("o1js").Bool[]>;
        _indicesInRange: Set<Field>;
        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
        toValue(): bigint[];
        [Symbol.iterator](): Generator<UInt32, void, unknown>;
    };
    initialState512: (l: 384 | 512) => {
        array: UInt64[];
        readonly innerType: Provable<UInt64, bigint>;
        readonly length: number;
        readonly maxLength: number;
        assertIndexInRange(i: UInt32 | number): void;
        get(i: UInt32 | number): UInt64;
        getOption(i: UInt32 | number): import("o1js").Option<UInt64>;
        getOrUnconstrained(i: Field): UInt64;
        set(i: UInt32 | number, value: UInt64): void;
        setOrDoNothing(i: Field, value: UInt64): void;
        map<S>(type: ProvableType<S>, f: (t: UInt64, i: number) => S): StaticArray<S, any>;
        forEach(f: (t: UInt64, i: number) => void): void;
        reduce<S>(state: S, f: (state: S, t: UInt64) => S): S;
        chunk(chunkSize: number): {
            array: /*elided*/ any[];
            readonly innerType: Provable</*elided*/ any, bigint[]>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): /*elided*/ any;
            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
            getOrUnconstrained(i: Field): /*elided*/ any;
            set(i: UInt32 | number, value: /*elided*/ any): void;
            setOrDoNothing(i: Field, value: /*elided*/ any): void;
            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: /*elided*/ any, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[][]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                getOrUnconstrained(i: Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                    getOrUnconstrained(i: Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                        getOrUnconstrained(i: Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                            getOrUnconstrained(i: Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                getOrUnconstrained(i: Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                    getOrUnconstrained(i: Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                        getOrUnconstrained(i: Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                            getOrUnconstrained(i: Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                                getOrUnconstrained(i: Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): /*elided*/ any;
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<Field>;
                                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<Field>;
                                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<Field>;
                                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<Field>;
                                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<Field>;
                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<Field>;
                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<Field>;
                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<Field>;
                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<Field, import("o1js").Bool[]>;
                _indicesInRange: Set<Field>;
                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<Field, import("o1js").Bool[]>;
            _indicesInRange: Set<Field>;
            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[][];
            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
        };
        toReversed(): /*elided*/ any;
        slice(start: number, end: number): /*elided*/ any;
        _indexMasks: Map<Field, import("o1js").Bool[]>;
        _indicesInRange: Set<Field>;
        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
        toValue(): bigint[];
        [Symbol.iterator](): Generator<UInt64, void, unknown>;
    };
};
declare function sha2(len: 224 | 256 | 384 | 512, bytes: DynamicArray<UInt8>): Bytes;
type Length = 224 | 256 | 384 | 512;
declare const Block32_base: {
    new (array: UInt32[]): {
        array: UInt32[];
        readonly innerType: Provable<UInt32, bigint>;
        readonly length: number;
        readonly maxLength: number;
        assertIndexInRange(i: UInt32 | number): void;
        get(i: UInt32 | number): UInt32;
        getOption(i: UInt32 | number): import("o1js").Option<UInt32>;
        getOrUnconstrained(i: Field): UInt32;
        set(i: UInt32 | number, value: UInt32): void;
        setOrDoNothing(i: Field, value: UInt32): void;
        map<S>(type: ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
        forEach(f: (t: UInt32, i: number) => void): void;
        reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
        chunk(chunkSize: number): {
            array: /*elided*/ any[];
            readonly innerType: Provable</*elided*/ any, bigint[]>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): /*elided*/ any;
            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
            getOrUnconstrained(i: Field): /*elided*/ any;
            set(i: UInt32 | number, value: /*elided*/ any): void;
            setOrDoNothing(i: Field, value: /*elided*/ any): void;
            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: /*elided*/ any, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[][]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                getOrUnconstrained(i: Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                    getOrUnconstrained(i: Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                        getOrUnconstrained(i: Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                            getOrUnconstrained(i: Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                getOrUnconstrained(i: Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                    getOrUnconstrained(i: Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                        getOrUnconstrained(i: Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                            getOrUnconstrained(i: Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                                getOrUnconstrained(i: Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): /*elided*/ any;
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<Field>;
                                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<Field>;
                                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<Field>;
                                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<Field>;
                                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<Field>;
                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<Field>;
                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<Field>;
                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<Field>;
                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<Field, import("o1js").Bool[]>;
                _indicesInRange: Set<Field>;
                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<Field, import("o1js").Bool[]>;
            _indicesInRange: Set<Field>;
            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[][];
            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
        };
        toReversed(): /*elided*/ any;
        slice(start: number, end: number): /*elided*/ any;
        _indexMasks: Map<Field, import("o1js").Bool[]>;
        _indicesInRange: Set<Field>;
        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
        toValue(): bigint[];
        [Symbol.iterator](): Generator<UInt32, void, unknown>;
    };
    readonly length: number;
} & Omit<{
    new (array: UInt32[]): {
        array: UInt32[];
        readonly innerType: Provable<UInt32, bigint>;
        readonly length: number;
        readonly maxLength: number;
        assertIndexInRange(i: UInt32 | number): void;
        get(i: UInt32 | number): UInt32;
        getOption(i: UInt32 | number): import("o1js").Option<UInt32>;
        getOrUnconstrained(i: Field): UInt32;
        set(i: UInt32 | number, value: UInt32): void;
        setOrDoNothing(i: Field, value: UInt32): void;
        map<S>(type: ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
        forEach(f: (t: UInt32, i: number) => void): void;
        reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
        chunk(chunkSize: number): {
            array: /*elided*/ any[];
            readonly innerType: Provable</*elided*/ any, bigint[]>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): /*elided*/ any;
            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
            getOrUnconstrained(i: Field): /*elided*/ any;
            set(i: UInt32 | number, value: /*elided*/ any): void;
            setOrDoNothing(i: Field, value: /*elided*/ any): void;
            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: /*elided*/ any, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[][]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                getOrUnconstrained(i: Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                    getOrUnconstrained(i: Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                        getOrUnconstrained(i: Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                            getOrUnconstrained(i: Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                getOrUnconstrained(i: Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                    getOrUnconstrained(i: Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                        getOrUnconstrained(i: Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                            getOrUnconstrained(i: Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                                getOrUnconstrained(i: Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): /*elided*/ any;
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<Field>;
                                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<Field>;
                                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<Field>;
                                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<Field>;
                                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<Field>;
                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<Field>;
                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<Field>;
                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<Field>;
                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<Field, import("o1js").Bool[]>;
                _indicesInRange: Set<Field>;
                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<Field, import("o1js").Bool[]>;
            _indicesInRange: Set<Field>;
            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[][];
            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
        };
        toReversed(): /*elided*/ any;
        slice(start: number, end: number): /*elided*/ any;
        _indexMasks: Map<Field, import("o1js").Bool[]>;
        _indicesInRange: Set<Field>;
        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
        toValue(): bigint[];
        [Symbol.iterator](): Generator<UInt32, void, unknown>;
    };
    readonly length: number;
} & {
    provable: import("../o1js-missing.ts").ProvableHashableWide<{
        array: UInt32[];
        readonly innerType: Provable<UInt32, bigint>;
        readonly length: number;
        readonly maxLength: number;
        assertIndexInRange(i: UInt32 | number): void;
        get(i: UInt32 | number): UInt32;
        getOption(i: UInt32 | number): import("o1js").Option<UInt32>;
        getOrUnconstrained(i: Field): UInt32;
        set(i: UInt32 | number, value: UInt32): void;
        setOrDoNothing(i: Field, value: UInt32): void;
        map<S>(type: ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
        forEach(f: (t: UInt32, i: number) => void): void;
        reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
        chunk(chunkSize: number): {
            array: /*elided*/ any[];
            readonly innerType: Provable</*elided*/ any, bigint[]>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): /*elided*/ any;
            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
            getOrUnconstrained(i: Field): /*elided*/ any;
            set(i: UInt32 | number, value: /*elided*/ any): void;
            setOrDoNothing(i: Field, value: /*elided*/ any): void;
            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: /*elided*/ any, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[][]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                getOrUnconstrained(i: Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                    getOrUnconstrained(i: Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                        getOrUnconstrained(i: Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                            getOrUnconstrained(i: Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                getOrUnconstrained(i: Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                    getOrUnconstrained(i: Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                        getOrUnconstrained(i: Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                            getOrUnconstrained(i: Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                                getOrUnconstrained(i: Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): /*elided*/ any;
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<Field>;
                                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<Field>;
                                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<Field>;
                                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<Field>;
                                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<Field>;
                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<Field>;
                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<Field>;
                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<Field>;
                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<Field, import("o1js").Bool[]>;
                _indicesInRange: Set<Field>;
                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<Field, import("o1js").Bool[]>;
            _indicesInRange: Set<Field>;
            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[][];
            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
        };
        toReversed(): /*elided*/ any;
        slice(start: number, end: number): /*elided*/ any;
        _indexMasks: Map<Field, import("o1js").Bool[]>;
        _indicesInRange: Set<Field>;
        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
        toValue(): bigint[];
        [Symbol.iterator](): Generator<UInt32, void, unknown>;
    }, bigint[], (number | bigint | UInt32)[]>;
    from(v: {
        array: UInt32[];
        readonly innerType: Provable<UInt32, bigint>;
        readonly length: number;
        readonly maxLength: number;
        assertIndexInRange(i: UInt32 | number): void;
        get(i: UInt32 | number): UInt32;
        getOption(i: UInt32 | number): import("o1js").Option<UInt32>;
        getOrUnconstrained(i: Field): UInt32;
        set(i: UInt32 | number, value: UInt32): void;
        setOrDoNothing(i: Field, value: UInt32): void;
        map<S>(type: ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
        forEach(f: (t: UInt32, i: number) => void): void;
        reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
        chunk(chunkSize: number): {
            array: /*elided*/ any[];
            readonly innerType: Provable</*elided*/ any, bigint[]>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): /*elided*/ any;
            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
            getOrUnconstrained(i: Field): /*elided*/ any;
            set(i: UInt32 | number, value: /*elided*/ any): void;
            setOrDoNothing(i: Field, value: /*elided*/ any): void;
            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: /*elided*/ any, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[][]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                getOrUnconstrained(i: Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                    getOrUnconstrained(i: Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                        getOrUnconstrained(i: Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                            getOrUnconstrained(i: Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                getOrUnconstrained(i: Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                    getOrUnconstrained(i: Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                        getOrUnconstrained(i: Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                            getOrUnconstrained(i: Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                                getOrUnconstrained(i: Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): /*elided*/ any;
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<Field>;
                                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<Field>;
                                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<Field>;
                                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<Field>;
                                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<Field>;
                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<Field>;
                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<Field>;
                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<Field>;
                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<Field, import("o1js").Bool[]>;
                _indicesInRange: Set<Field>;
                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<Field, import("o1js").Bool[]>;
            _indicesInRange: Set<Field>;
            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[][];
            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
        };
        toReversed(): /*elided*/ any;
        slice(start: number, end: number): /*elided*/ any;
        _indexMasks: Map<Field, import("o1js").Bool[]>;
        _indicesInRange: Set<Field>;
        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
        toValue(): bigint[];
        [Symbol.iterator](): Generator<UInt32, void, unknown>;
    } | (number | bigint | UInt32)[]): {
        array: UInt32[];
        readonly innerType: Provable<UInt32, bigint>;
        readonly length: number;
        readonly maxLength: number;
        assertIndexInRange(i: UInt32 | number): void;
        get(i: UInt32 | number): UInt32;
        getOption(i: UInt32 | number): import("o1js").Option<UInt32>;
        getOrUnconstrained(i: Field): UInt32;
        set(i: UInt32 | number, value: UInt32): void;
        setOrDoNothing(i: Field, value: UInt32): void;
        map<S>(type: ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
        forEach(f: (t: UInt32, i: number) => void): void;
        reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
        chunk(chunkSize: number): {
            array: /*elided*/ any[];
            readonly innerType: Provable</*elided*/ any, bigint[]>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): /*elided*/ any;
            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
            getOrUnconstrained(i: Field): /*elided*/ any;
            set(i: UInt32 | number, value: /*elided*/ any): void;
            setOrDoNothing(i: Field, value: /*elided*/ any): void;
            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: /*elided*/ any, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[][]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                getOrUnconstrained(i: Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                    getOrUnconstrained(i: Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                        getOrUnconstrained(i: Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                            getOrUnconstrained(i: Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                getOrUnconstrained(i: Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                    getOrUnconstrained(i: Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                        getOrUnconstrained(i: Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                            getOrUnconstrained(i: Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                                getOrUnconstrained(i: Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): /*elided*/ any;
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<Field>;
                                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<Field>;
                                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<Field>;
                                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<Field>;
                                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<Field>;
                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<Field>;
                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<Field>;
                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<Field>;
                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<Field, import("o1js").Bool[]>;
                _indicesInRange: Set<Field>;
                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<Field, import("o1js").Bool[]>;
            _indicesInRange: Set<Field>;
            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[][];
            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
        };
        toReversed(): /*elided*/ any;
        slice(start: number, end: number): /*elided*/ any;
        _indexMasks: Map<Field, import("o1js").Bool[]>;
        _indicesInRange: Set<Field>;
        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
        toValue(): bigint[];
        [Symbol.iterator](): Generator<UInt32, void, unknown>;
    };
}, "provable"> & {
    provable: Omit<import("o1js").ProvableHashable<{
        array: UInt32[];
        readonly innerType: Provable<UInt32, bigint>;
        readonly length: number;
        readonly maxLength: number;
        assertIndexInRange(i: UInt32 | number): void;
        get(i: UInt32 | number): UInt32;
        getOption(i: UInt32 | number): import("o1js").Option<UInt32>;
        getOrUnconstrained(i: Field): UInt32;
        set(i: UInt32 | number, value: UInt32): void;
        setOrDoNothing(i: Field, value: UInt32): void;
        map<S>(type: ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
        forEach(f: (t: UInt32, i: number) => void): void;
        reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
        chunk(chunkSize: number): {
            array: /*elided*/ any[];
            readonly innerType: Provable</*elided*/ any, bigint[]>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): /*elided*/ any;
            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
            getOrUnconstrained(i: Field): /*elided*/ any;
            set(i: UInt32 | number, value: /*elided*/ any): void;
            setOrDoNothing(i: Field, value: /*elided*/ any): void;
            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: /*elided*/ any, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[][]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                getOrUnconstrained(i: Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                    getOrUnconstrained(i: Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                        getOrUnconstrained(i: Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                            getOrUnconstrained(i: Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                getOrUnconstrained(i: Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                    getOrUnconstrained(i: Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                        getOrUnconstrained(i: Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                            getOrUnconstrained(i: Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                                getOrUnconstrained(i: Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): /*elided*/ any;
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<Field>;
                                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<Field>;
                                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<Field>;
                                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<Field>;
                                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<Field>;
                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<Field>;
                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<Field>;
                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<Field>;
                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<Field, import("o1js").Bool[]>;
                _indicesInRange: Set<Field>;
                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<Field, import("o1js").Bool[]>;
            _indicesInRange: Set<Field>;
            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[][];
            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
        };
        toReversed(): /*elided*/ any;
        slice(start: number, end: number): /*elided*/ any;
        _indexMasks: Map<Field, import("o1js").Bool[]>;
        _indicesInRange: Set<Field>;
        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
        toValue(): bigint[];
        [Symbol.iterator](): Generator<UInt32, void, unknown>;
    }, bigint[]>, "fromValue"> & {
        fromValue: (value: {
            array: UInt32[];
            readonly innerType: Provable<UInt32, bigint>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): UInt32;
            getOption(i: UInt32 | number): import("o1js").Option<UInt32>;
            getOrUnconstrained(i: Field): UInt32;
            set(i: UInt32 | number, value: UInt32): void;
            setOrDoNothing(i: Field, value: UInt32): void;
            map<S>(type: ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: UInt32, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                getOrUnconstrained(i: Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                    getOrUnconstrained(i: Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                        getOrUnconstrained(i: Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                            getOrUnconstrained(i: Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                getOrUnconstrained(i: Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                    getOrUnconstrained(i: Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                        getOrUnconstrained(i: Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                            getOrUnconstrained(i: Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                                getOrUnconstrained(i: Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): {
                                                    array: /*elided*/ any[];
                                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                    readonly length: number;
                                                    readonly maxLength: number;
                                                    assertIndexInRange(i: UInt32 | number): void;
                                                    get(i: UInt32 | number): /*elided*/ any;
                                                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                                    getOrUnconstrained(i: Field): /*elided*/ any;
                                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                    chunk(chunkSize: number): /*elided*/ any;
                                                    toReversed(): /*elided*/ any;
                                                    slice(start: number, end: number): /*elided*/ any;
                                                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                                                    _indicesInRange: Set<Field>;
                                                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                    toValue(): bigint[][][][][][][][][][][];
                                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                                };
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<Field>;
                                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<Field>;
                                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<Field>;
                                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<Field>;
                                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<Field>;
                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<Field>;
                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<Field>;
                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<Field>;
                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<Field, import("o1js").Bool[]>;
                _indicesInRange: Set<Field>;
                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<Field, import("o1js").Bool[]>;
            _indicesInRange: Set<Field>;
            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[];
            [Symbol.iterator](): Generator<UInt32, void, unknown>;
        } | (number | bigint | UInt32)[]) => {
            array: UInt32[];
            readonly innerType: Provable<UInt32, bigint>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): UInt32;
            getOption(i: UInt32 | number): import("o1js").Option<UInt32>;
            getOrUnconstrained(i: Field): UInt32;
            set(i: UInt32 | number, value: UInt32): void;
            setOrDoNothing(i: Field, value: UInt32): void;
            map<S>(type: ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: UInt32, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                getOrUnconstrained(i: Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                    getOrUnconstrained(i: Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                        getOrUnconstrained(i: Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                            getOrUnconstrained(i: Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                getOrUnconstrained(i: Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                    getOrUnconstrained(i: Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                        getOrUnconstrained(i: Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                            getOrUnconstrained(i: Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                                getOrUnconstrained(i: Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): {
                                                    array: /*elided*/ any[];
                                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                    readonly length: number;
                                                    readonly maxLength: number;
                                                    assertIndexInRange(i: UInt32 | number): void;
                                                    get(i: UInt32 | number): /*elided*/ any;
                                                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                                    getOrUnconstrained(i: Field): /*elided*/ any;
                                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                    chunk(chunkSize: number): /*elided*/ any;
                                                    toReversed(): /*elided*/ any;
                                                    slice(start: number, end: number): /*elided*/ any;
                                                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                                                    _indicesInRange: Set<Field>;
                                                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                    toValue(): bigint[][][][][][][][][][][];
                                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                                };
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<Field>;
                                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<Field>;
                                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<Field>;
                                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<Field>;
                                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<Field>;
                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<Field>;
                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<Field>;
                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<Field>;
                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<Field, import("o1js").Bool[]>;
                _indicesInRange: Set<Field>;
                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<Field, import("o1js").Bool[]>;
            _indicesInRange: Set<Field>;
            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[];
            [Symbol.iterator](): Generator<UInt32, void, unknown>;
        };
    } & Omit<import("o1js").ProvablePure<{
        array: UInt32[];
        readonly innerType: Provable<UInt32, bigint>;
        readonly length: number;
        readonly maxLength: number;
        assertIndexInRange(i: UInt32 | number): void;
        get(i: UInt32 | number): UInt32;
        getOption(i: UInt32 | number): import("o1js").Option<UInt32>;
        getOrUnconstrained(i: Field): UInt32;
        set(i: UInt32 | number, value: UInt32): void;
        setOrDoNothing(i: Field, value: UInt32): void;
        map<S>(type: ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
        forEach(f: (t: UInt32, i: number) => void): void;
        reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
        chunk(chunkSize: number): {
            array: /*elided*/ any[];
            readonly innerType: Provable</*elided*/ any, bigint[]>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): /*elided*/ any;
            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
            getOrUnconstrained(i: Field): /*elided*/ any;
            set(i: UInt32 | number, value: /*elided*/ any): void;
            setOrDoNothing(i: Field, value: /*elided*/ any): void;
            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: /*elided*/ any, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[][]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                getOrUnconstrained(i: Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                    getOrUnconstrained(i: Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                        getOrUnconstrained(i: Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                            getOrUnconstrained(i: Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                getOrUnconstrained(i: Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                    getOrUnconstrained(i: Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                        getOrUnconstrained(i: Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                            getOrUnconstrained(i: Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                                getOrUnconstrained(i: Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): /*elided*/ any;
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<Field>;
                                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<Field>;
                                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<Field>;
                                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<Field>;
                                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<Field>;
                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<Field>;
                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<Field>;
                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<Field>;
                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<Field, import("o1js").Bool[]>;
                _indicesInRange: Set<Field>;
                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<Field, import("o1js").Bool[]>;
            _indicesInRange: Set<Field>;
            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[][];
            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
        };
        toReversed(): /*elided*/ any;
        slice(start: number, end: number): /*elided*/ any;
        _indexMasks: Map<Field, import("o1js").Bool[]>;
        _indicesInRange: Set<Field>;
        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
        toValue(): bigint[];
        [Symbol.iterator](): Generator<UInt32, void, unknown>;
    }, bigint[]>, "fromValue">;
};
declare class Block32 extends Block32_base {
}
declare const State32_base: {
    new (array: UInt32[]): {
        array: UInt32[];
        readonly innerType: Provable<UInt32, bigint>;
        readonly length: number;
        readonly maxLength: number;
        assertIndexInRange(i: UInt32 | number): void;
        get(i: UInt32 | number): UInt32;
        getOption(i: UInt32 | number): import("o1js").Option<UInt32>;
        getOrUnconstrained(i: Field): UInt32;
        set(i: UInt32 | number, value: UInt32): void;
        setOrDoNothing(i: Field, value: UInt32): void;
        map<S>(type: ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
        forEach(f: (t: UInt32, i: number) => void): void;
        reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
        chunk(chunkSize: number): {
            array: /*elided*/ any[];
            readonly innerType: Provable</*elided*/ any, bigint[]>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): /*elided*/ any;
            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
            getOrUnconstrained(i: Field): /*elided*/ any;
            set(i: UInt32 | number, value: /*elided*/ any): void;
            setOrDoNothing(i: Field, value: /*elided*/ any): void;
            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: /*elided*/ any, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[][]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                getOrUnconstrained(i: Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                    getOrUnconstrained(i: Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                        getOrUnconstrained(i: Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                            getOrUnconstrained(i: Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                getOrUnconstrained(i: Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                    getOrUnconstrained(i: Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                        getOrUnconstrained(i: Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                            getOrUnconstrained(i: Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                                getOrUnconstrained(i: Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): /*elided*/ any;
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<Field>;
                                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<Field>;
                                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<Field>;
                                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<Field>;
                                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<Field>;
                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<Field>;
                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<Field>;
                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<Field>;
                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<Field, import("o1js").Bool[]>;
                _indicesInRange: Set<Field>;
                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<Field, import("o1js").Bool[]>;
            _indicesInRange: Set<Field>;
            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[][];
            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
        };
        toReversed(): /*elided*/ any;
        slice(start: number, end: number): /*elided*/ any;
        _indexMasks: Map<Field, import("o1js").Bool[]>;
        _indicesInRange: Set<Field>;
        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
        toValue(): bigint[];
        [Symbol.iterator](): Generator<UInt32, void, unknown>;
    };
    readonly length: number;
} & Omit<{
    new (array: UInt32[]): {
        array: UInt32[];
        readonly innerType: Provable<UInt32, bigint>;
        readonly length: number;
        readonly maxLength: number;
        assertIndexInRange(i: UInt32 | number): void;
        get(i: UInt32 | number): UInt32;
        getOption(i: UInt32 | number): import("o1js").Option<UInt32>;
        getOrUnconstrained(i: Field): UInt32;
        set(i: UInt32 | number, value: UInt32): void;
        setOrDoNothing(i: Field, value: UInt32): void;
        map<S>(type: ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
        forEach(f: (t: UInt32, i: number) => void): void;
        reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
        chunk(chunkSize: number): {
            array: /*elided*/ any[];
            readonly innerType: Provable</*elided*/ any, bigint[]>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): /*elided*/ any;
            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
            getOrUnconstrained(i: Field): /*elided*/ any;
            set(i: UInt32 | number, value: /*elided*/ any): void;
            setOrDoNothing(i: Field, value: /*elided*/ any): void;
            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: /*elided*/ any, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[][]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                getOrUnconstrained(i: Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                    getOrUnconstrained(i: Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                        getOrUnconstrained(i: Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                            getOrUnconstrained(i: Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                getOrUnconstrained(i: Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                    getOrUnconstrained(i: Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                        getOrUnconstrained(i: Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                            getOrUnconstrained(i: Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                                getOrUnconstrained(i: Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): /*elided*/ any;
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<Field>;
                                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<Field>;
                                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<Field>;
                                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<Field>;
                                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<Field>;
                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<Field>;
                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<Field>;
                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<Field>;
                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<Field, import("o1js").Bool[]>;
                _indicesInRange: Set<Field>;
                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<Field, import("o1js").Bool[]>;
            _indicesInRange: Set<Field>;
            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[][];
            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
        };
        toReversed(): /*elided*/ any;
        slice(start: number, end: number): /*elided*/ any;
        _indexMasks: Map<Field, import("o1js").Bool[]>;
        _indicesInRange: Set<Field>;
        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
        toValue(): bigint[];
        [Symbol.iterator](): Generator<UInt32, void, unknown>;
    };
    readonly length: number;
} & {
    provable: import("../o1js-missing.ts").ProvableHashableWide<{
        array: UInt32[];
        readonly innerType: Provable<UInt32, bigint>;
        readonly length: number;
        readonly maxLength: number;
        assertIndexInRange(i: UInt32 | number): void;
        get(i: UInt32 | number): UInt32;
        getOption(i: UInt32 | number): import("o1js").Option<UInt32>;
        getOrUnconstrained(i: Field): UInt32;
        set(i: UInt32 | number, value: UInt32): void;
        setOrDoNothing(i: Field, value: UInt32): void;
        map<S>(type: ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
        forEach(f: (t: UInt32, i: number) => void): void;
        reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
        chunk(chunkSize: number): {
            array: /*elided*/ any[];
            readonly innerType: Provable</*elided*/ any, bigint[]>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): /*elided*/ any;
            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
            getOrUnconstrained(i: Field): /*elided*/ any;
            set(i: UInt32 | number, value: /*elided*/ any): void;
            setOrDoNothing(i: Field, value: /*elided*/ any): void;
            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: /*elided*/ any, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[][]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                getOrUnconstrained(i: Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                    getOrUnconstrained(i: Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                        getOrUnconstrained(i: Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                            getOrUnconstrained(i: Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                getOrUnconstrained(i: Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                    getOrUnconstrained(i: Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                        getOrUnconstrained(i: Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                            getOrUnconstrained(i: Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                                getOrUnconstrained(i: Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): /*elided*/ any;
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<Field>;
                                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<Field>;
                                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<Field>;
                                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<Field>;
                                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<Field>;
                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<Field>;
                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<Field>;
                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<Field>;
                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<Field, import("o1js").Bool[]>;
                _indicesInRange: Set<Field>;
                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<Field, import("o1js").Bool[]>;
            _indicesInRange: Set<Field>;
            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[][];
            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
        };
        toReversed(): /*elided*/ any;
        slice(start: number, end: number): /*elided*/ any;
        _indexMasks: Map<Field, import("o1js").Bool[]>;
        _indicesInRange: Set<Field>;
        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
        toValue(): bigint[];
        [Symbol.iterator](): Generator<UInt32, void, unknown>;
    }, bigint[], (number | bigint | UInt32)[]>;
    from(v: {
        array: UInt32[];
        readonly innerType: Provable<UInt32, bigint>;
        readonly length: number;
        readonly maxLength: number;
        assertIndexInRange(i: UInt32 | number): void;
        get(i: UInt32 | number): UInt32;
        getOption(i: UInt32 | number): import("o1js").Option<UInt32>;
        getOrUnconstrained(i: Field): UInt32;
        set(i: UInt32 | number, value: UInt32): void;
        setOrDoNothing(i: Field, value: UInt32): void;
        map<S>(type: ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
        forEach(f: (t: UInt32, i: number) => void): void;
        reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
        chunk(chunkSize: number): {
            array: /*elided*/ any[];
            readonly innerType: Provable</*elided*/ any, bigint[]>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): /*elided*/ any;
            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
            getOrUnconstrained(i: Field): /*elided*/ any;
            set(i: UInt32 | number, value: /*elided*/ any): void;
            setOrDoNothing(i: Field, value: /*elided*/ any): void;
            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: /*elided*/ any, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[][]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                getOrUnconstrained(i: Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                    getOrUnconstrained(i: Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                        getOrUnconstrained(i: Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                            getOrUnconstrained(i: Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                getOrUnconstrained(i: Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                    getOrUnconstrained(i: Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                        getOrUnconstrained(i: Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                            getOrUnconstrained(i: Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                                getOrUnconstrained(i: Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): /*elided*/ any;
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<Field>;
                                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<Field>;
                                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<Field>;
                                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<Field>;
                                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<Field>;
                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<Field>;
                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<Field>;
                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<Field>;
                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<Field, import("o1js").Bool[]>;
                _indicesInRange: Set<Field>;
                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<Field, import("o1js").Bool[]>;
            _indicesInRange: Set<Field>;
            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[][];
            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
        };
        toReversed(): /*elided*/ any;
        slice(start: number, end: number): /*elided*/ any;
        _indexMasks: Map<Field, import("o1js").Bool[]>;
        _indicesInRange: Set<Field>;
        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
        toValue(): bigint[];
        [Symbol.iterator](): Generator<UInt32, void, unknown>;
    } | (number | bigint | UInt32)[]): {
        array: UInt32[];
        readonly innerType: Provable<UInt32, bigint>;
        readonly length: number;
        readonly maxLength: number;
        assertIndexInRange(i: UInt32 | number): void;
        get(i: UInt32 | number): UInt32;
        getOption(i: UInt32 | number): import("o1js").Option<UInt32>;
        getOrUnconstrained(i: Field): UInt32;
        set(i: UInt32 | number, value: UInt32): void;
        setOrDoNothing(i: Field, value: UInt32): void;
        map<S>(type: ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
        forEach(f: (t: UInt32, i: number) => void): void;
        reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
        chunk(chunkSize: number): {
            array: /*elided*/ any[];
            readonly innerType: Provable</*elided*/ any, bigint[]>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): /*elided*/ any;
            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
            getOrUnconstrained(i: Field): /*elided*/ any;
            set(i: UInt32 | number, value: /*elided*/ any): void;
            setOrDoNothing(i: Field, value: /*elided*/ any): void;
            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: /*elided*/ any, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[][]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                getOrUnconstrained(i: Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                    getOrUnconstrained(i: Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                        getOrUnconstrained(i: Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                            getOrUnconstrained(i: Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                getOrUnconstrained(i: Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                    getOrUnconstrained(i: Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                        getOrUnconstrained(i: Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                            getOrUnconstrained(i: Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                                getOrUnconstrained(i: Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): /*elided*/ any;
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<Field>;
                                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<Field>;
                                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<Field>;
                                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<Field>;
                                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<Field>;
                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<Field>;
                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<Field>;
                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<Field>;
                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<Field, import("o1js").Bool[]>;
                _indicesInRange: Set<Field>;
                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<Field, import("o1js").Bool[]>;
            _indicesInRange: Set<Field>;
            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[][];
            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
        };
        toReversed(): /*elided*/ any;
        slice(start: number, end: number): /*elided*/ any;
        _indexMasks: Map<Field, import("o1js").Bool[]>;
        _indicesInRange: Set<Field>;
        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
        toValue(): bigint[];
        [Symbol.iterator](): Generator<UInt32, void, unknown>;
    };
}, "provable"> & {
    provable: Omit<import("o1js").ProvableHashable<{
        array: UInt32[];
        readonly innerType: Provable<UInt32, bigint>;
        readonly length: number;
        readonly maxLength: number;
        assertIndexInRange(i: UInt32 | number): void;
        get(i: UInt32 | number): UInt32;
        getOption(i: UInt32 | number): import("o1js").Option<UInt32>;
        getOrUnconstrained(i: Field): UInt32;
        set(i: UInt32 | number, value: UInt32): void;
        setOrDoNothing(i: Field, value: UInt32): void;
        map<S>(type: ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
        forEach(f: (t: UInt32, i: number) => void): void;
        reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
        chunk(chunkSize: number): {
            array: /*elided*/ any[];
            readonly innerType: Provable</*elided*/ any, bigint[]>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): /*elided*/ any;
            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
            getOrUnconstrained(i: Field): /*elided*/ any;
            set(i: UInt32 | number, value: /*elided*/ any): void;
            setOrDoNothing(i: Field, value: /*elided*/ any): void;
            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: /*elided*/ any, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[][]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                getOrUnconstrained(i: Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                    getOrUnconstrained(i: Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                        getOrUnconstrained(i: Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                            getOrUnconstrained(i: Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                getOrUnconstrained(i: Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                    getOrUnconstrained(i: Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                        getOrUnconstrained(i: Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                            getOrUnconstrained(i: Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                                getOrUnconstrained(i: Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): /*elided*/ any;
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<Field>;
                                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<Field>;
                                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<Field>;
                                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<Field>;
                                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<Field>;
                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<Field>;
                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<Field>;
                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<Field>;
                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<Field, import("o1js").Bool[]>;
                _indicesInRange: Set<Field>;
                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<Field, import("o1js").Bool[]>;
            _indicesInRange: Set<Field>;
            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[][];
            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
        };
        toReversed(): /*elided*/ any;
        slice(start: number, end: number): /*elided*/ any;
        _indexMasks: Map<Field, import("o1js").Bool[]>;
        _indicesInRange: Set<Field>;
        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
        toValue(): bigint[];
        [Symbol.iterator](): Generator<UInt32, void, unknown>;
    }, bigint[]>, "fromValue"> & {
        fromValue: (value: {
            array: UInt32[];
            readonly innerType: Provable<UInt32, bigint>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): UInt32;
            getOption(i: UInt32 | number): import("o1js").Option<UInt32>;
            getOrUnconstrained(i: Field): UInt32;
            set(i: UInt32 | number, value: UInt32): void;
            setOrDoNothing(i: Field, value: UInt32): void;
            map<S>(type: ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: UInt32, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                getOrUnconstrained(i: Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                    getOrUnconstrained(i: Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                        getOrUnconstrained(i: Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                            getOrUnconstrained(i: Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                getOrUnconstrained(i: Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                    getOrUnconstrained(i: Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                        getOrUnconstrained(i: Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                            getOrUnconstrained(i: Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                                getOrUnconstrained(i: Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): {
                                                    array: /*elided*/ any[];
                                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                    readonly length: number;
                                                    readonly maxLength: number;
                                                    assertIndexInRange(i: UInt32 | number): void;
                                                    get(i: UInt32 | number): /*elided*/ any;
                                                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                                    getOrUnconstrained(i: Field): /*elided*/ any;
                                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                    chunk(chunkSize: number): /*elided*/ any;
                                                    toReversed(): /*elided*/ any;
                                                    slice(start: number, end: number): /*elided*/ any;
                                                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                                                    _indicesInRange: Set<Field>;
                                                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                    toValue(): bigint[][][][][][][][][][][];
                                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                                };
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<Field>;
                                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<Field>;
                                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<Field>;
                                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<Field>;
                                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<Field>;
                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<Field>;
                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<Field>;
                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<Field>;
                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<Field, import("o1js").Bool[]>;
                _indicesInRange: Set<Field>;
                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<Field, import("o1js").Bool[]>;
            _indicesInRange: Set<Field>;
            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[];
            [Symbol.iterator](): Generator<UInt32, void, unknown>;
        } | (number | bigint | UInt32)[]) => {
            array: UInt32[];
            readonly innerType: Provable<UInt32, bigint>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): UInt32;
            getOption(i: UInt32 | number): import("o1js").Option<UInt32>;
            getOrUnconstrained(i: Field): UInt32;
            set(i: UInt32 | number, value: UInt32): void;
            setOrDoNothing(i: Field, value: UInt32): void;
            map<S>(type: ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: UInt32, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                getOrUnconstrained(i: Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                    getOrUnconstrained(i: Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                        getOrUnconstrained(i: Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                            getOrUnconstrained(i: Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                getOrUnconstrained(i: Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                    getOrUnconstrained(i: Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                        getOrUnconstrained(i: Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                            getOrUnconstrained(i: Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                                getOrUnconstrained(i: Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): {
                                                    array: /*elided*/ any[];
                                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                    readonly length: number;
                                                    readonly maxLength: number;
                                                    assertIndexInRange(i: UInt32 | number): void;
                                                    get(i: UInt32 | number): /*elided*/ any;
                                                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                                    getOrUnconstrained(i: Field): /*elided*/ any;
                                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                    chunk(chunkSize: number): /*elided*/ any;
                                                    toReversed(): /*elided*/ any;
                                                    slice(start: number, end: number): /*elided*/ any;
                                                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                                                    _indicesInRange: Set<Field>;
                                                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                    toValue(): bigint[][][][][][][][][][][];
                                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                                };
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<Field>;
                                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<Field>;
                                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<Field>;
                                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<Field>;
                                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<Field>;
                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<Field>;
                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<Field>;
                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<Field>;
                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<Field, import("o1js").Bool[]>;
                _indicesInRange: Set<Field>;
                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<Field, import("o1js").Bool[]>;
            _indicesInRange: Set<Field>;
            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[];
            [Symbol.iterator](): Generator<UInt32, void, unknown>;
        };
    } & Omit<import("o1js").ProvablePure<{
        array: UInt32[];
        readonly innerType: Provable<UInt32, bigint>;
        readonly length: number;
        readonly maxLength: number;
        assertIndexInRange(i: UInt32 | number): void;
        get(i: UInt32 | number): UInt32;
        getOption(i: UInt32 | number): import("o1js").Option<UInt32>;
        getOrUnconstrained(i: Field): UInt32;
        set(i: UInt32 | number, value: UInt32): void;
        setOrDoNothing(i: Field, value: UInt32): void;
        map<S>(type: ProvableType<S>, f: (t: UInt32, i: number) => S): StaticArray<S, any>;
        forEach(f: (t: UInt32, i: number) => void): void;
        reduce<S>(state: S, f: (state: S, t: UInt32) => S): S;
        chunk(chunkSize: number): {
            array: /*elided*/ any[];
            readonly innerType: Provable</*elided*/ any, bigint[]>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): /*elided*/ any;
            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
            getOrUnconstrained(i: Field): /*elided*/ any;
            set(i: UInt32 | number, value: /*elided*/ any): void;
            setOrDoNothing(i: Field, value: /*elided*/ any): void;
            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: /*elided*/ any, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[][]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                getOrUnconstrained(i: Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                    getOrUnconstrained(i: Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                        getOrUnconstrained(i: Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                            getOrUnconstrained(i: Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                getOrUnconstrained(i: Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                    getOrUnconstrained(i: Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                        getOrUnconstrained(i: Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                            getOrUnconstrained(i: Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                                getOrUnconstrained(i: Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): /*elided*/ any;
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<Field>;
                                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<Field>;
                                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<Field>;
                                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<Field>;
                                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<Field>;
                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<Field>;
                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<Field>;
                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<Field>;
                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<Field, import("o1js").Bool[]>;
                _indicesInRange: Set<Field>;
                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<Field, import("o1js").Bool[]>;
            _indicesInRange: Set<Field>;
            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[][];
            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
        };
        toReversed(): /*elided*/ any;
        slice(start: number, end: number): /*elided*/ any;
        _indexMasks: Map<Field, import("o1js").Bool[]>;
        _indicesInRange: Set<Field>;
        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
        toValue(): bigint[];
        [Symbol.iterator](): Generator<UInt32, void, unknown>;
    }, bigint[]>, "fromValue">;
};
declare class State32 extends State32_base {
}
declare const Block64_base: {
    new (array: UInt64[]): {
        array: UInt64[];
        readonly innerType: Provable<UInt64, bigint>;
        readonly length: number;
        readonly maxLength: number;
        assertIndexInRange(i: UInt32 | number): void;
        get(i: UInt32 | number): UInt64;
        getOption(i: UInt32 | number): import("o1js").Option<UInt64>;
        getOrUnconstrained(i: Field): UInt64;
        set(i: UInt32 | number, value: UInt64): void;
        setOrDoNothing(i: Field, value: UInt64): void;
        map<S>(type: ProvableType<S>, f: (t: UInt64, i: number) => S): StaticArray<S, any>;
        forEach(f: (t: UInt64, i: number) => void): void;
        reduce<S>(state: S, f: (state: S, t: UInt64) => S): S;
        chunk(chunkSize: number): {
            array: /*elided*/ any[];
            readonly innerType: Provable</*elided*/ any, bigint[]>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): /*elided*/ any;
            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
            getOrUnconstrained(i: Field): /*elided*/ any;
            set(i: UInt32 | number, value: /*elided*/ any): void;
            setOrDoNothing(i: Field, value: /*elided*/ any): void;
            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: /*elided*/ any, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[][]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                getOrUnconstrained(i: Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                    getOrUnconstrained(i: Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                        getOrUnconstrained(i: Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                            getOrUnconstrained(i: Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                getOrUnconstrained(i: Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                    getOrUnconstrained(i: Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                        getOrUnconstrained(i: Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                            getOrUnconstrained(i: Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                                getOrUnconstrained(i: Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): /*elided*/ any;
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<Field>;
                                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<Field>;
                                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<Field>;
                                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<Field>;
                                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<Field>;
                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<Field>;
                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<Field>;
                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<Field>;
                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<Field, import("o1js").Bool[]>;
                _indicesInRange: Set<Field>;
                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<Field, import("o1js").Bool[]>;
            _indicesInRange: Set<Field>;
            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[][];
            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
        };
        toReversed(): /*elided*/ any;
        slice(start: number, end: number): /*elided*/ any;
        _indexMasks: Map<Field, import("o1js").Bool[]>;
        _indicesInRange: Set<Field>;
        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
        toValue(): bigint[];
        [Symbol.iterator](): Generator<UInt64, void, unknown>;
    };
    readonly length: number;
} & Omit<{
    new (array: UInt64[]): {
        array: UInt64[];
        readonly innerType: Provable<UInt64, bigint>;
        readonly length: number;
        readonly maxLength: number;
        assertIndexInRange(i: UInt32 | number): void;
        get(i: UInt32 | number): UInt64;
        getOption(i: UInt32 | number): import("o1js").Option<UInt64>;
        getOrUnconstrained(i: Field): UInt64;
        set(i: UInt32 | number, value: UInt64): void;
        setOrDoNothing(i: Field, value: UInt64): void;
        map<S>(type: ProvableType<S>, f: (t: UInt64, i: number) => S): StaticArray<S, any>;
        forEach(f: (t: UInt64, i: number) => void): void;
        reduce<S>(state: S, f: (state: S, t: UInt64) => S): S;
        chunk(chunkSize: number): {
            array: /*elided*/ any[];
            readonly innerType: Provable</*elided*/ any, bigint[]>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): /*elided*/ any;
            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
            getOrUnconstrained(i: Field): /*elided*/ any;
            set(i: UInt32 | number, value: /*elided*/ any): void;
            setOrDoNothing(i: Field, value: /*elided*/ any): void;
            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: /*elided*/ any, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[][]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                getOrUnconstrained(i: Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                    getOrUnconstrained(i: Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                        getOrUnconstrained(i: Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                            getOrUnconstrained(i: Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                getOrUnconstrained(i: Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                    getOrUnconstrained(i: Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                        getOrUnconstrained(i: Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                            getOrUnconstrained(i: Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                                getOrUnconstrained(i: Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): /*elided*/ any;
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<Field>;
                                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<Field>;
                                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<Field>;
                                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<Field>;
                                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<Field>;
                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<Field>;
                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<Field>;
                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<Field>;
                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<Field, import("o1js").Bool[]>;
                _indicesInRange: Set<Field>;
                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<Field, import("o1js").Bool[]>;
            _indicesInRange: Set<Field>;
            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[][];
            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
        };
        toReversed(): /*elided*/ any;
        slice(start: number, end: number): /*elided*/ any;
        _indexMasks: Map<Field, import("o1js").Bool[]>;
        _indicesInRange: Set<Field>;
        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
        toValue(): bigint[];
        [Symbol.iterator](): Generator<UInt64, void, unknown>;
    };
    readonly length: number;
} & {
    provable: import("../o1js-missing.ts").ProvableHashableWide<{
        array: UInt64[];
        readonly innerType: Provable<UInt64, bigint>;
        readonly length: number;
        readonly maxLength: number;
        assertIndexInRange(i: UInt32 | number): void;
        get(i: UInt32 | number): UInt64;
        getOption(i: UInt32 | number): import("o1js").Option<UInt64>;
        getOrUnconstrained(i: Field): UInt64;
        set(i: UInt32 | number, value: UInt64): void;
        setOrDoNothing(i: Field, value: UInt64): void;
        map<S>(type: ProvableType<S>, f: (t: UInt64, i: number) => S): StaticArray<S, any>;
        forEach(f: (t: UInt64, i: number) => void): void;
        reduce<S>(state: S, f: (state: S, t: UInt64) => S): S;
        chunk(chunkSize: number): {
            array: /*elided*/ any[];
            readonly innerType: Provable</*elided*/ any, bigint[]>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): /*elided*/ any;
            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
            getOrUnconstrained(i: Field): /*elided*/ any;
            set(i: UInt32 | number, value: /*elided*/ any): void;
            setOrDoNothing(i: Field, value: /*elided*/ any): void;
            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: /*elided*/ any, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[][]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                getOrUnconstrained(i: Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                    getOrUnconstrained(i: Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                        getOrUnconstrained(i: Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                            getOrUnconstrained(i: Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                getOrUnconstrained(i: Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                    getOrUnconstrained(i: Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                        getOrUnconstrained(i: Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                            getOrUnconstrained(i: Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                                getOrUnconstrained(i: Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): /*elided*/ any;
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<Field>;
                                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<Field>;
                                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<Field>;
                                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<Field>;
                                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<Field>;
                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<Field>;
                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<Field>;
                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<Field>;
                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<Field, import("o1js").Bool[]>;
                _indicesInRange: Set<Field>;
                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<Field, import("o1js").Bool[]>;
            _indicesInRange: Set<Field>;
            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[][];
            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
        };
        toReversed(): /*elided*/ any;
        slice(start: number, end: number): /*elided*/ any;
        _indexMasks: Map<Field, import("o1js").Bool[]>;
        _indicesInRange: Set<Field>;
        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
        toValue(): bigint[];
        [Symbol.iterator](): Generator<UInt64, void, unknown>;
    }, bigint[], (number | bigint | UInt64)[]>;
    from(v: {
        array: UInt64[];
        readonly innerType: Provable<UInt64, bigint>;
        readonly length: number;
        readonly maxLength: number;
        assertIndexInRange(i: UInt32 | number): void;
        get(i: UInt32 | number): UInt64;
        getOption(i: UInt32 | number): import("o1js").Option<UInt64>;
        getOrUnconstrained(i: Field): UInt64;
        set(i: UInt32 | number, value: UInt64): void;
        setOrDoNothing(i: Field, value: UInt64): void;
        map<S>(type: ProvableType<S>, f: (t: UInt64, i: number) => S): StaticArray<S, any>;
        forEach(f: (t: UInt64, i: number) => void): void;
        reduce<S>(state: S, f: (state: S, t: UInt64) => S): S;
        chunk(chunkSize: number): {
            array: /*elided*/ any[];
            readonly innerType: Provable</*elided*/ any, bigint[]>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): /*elided*/ any;
            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
            getOrUnconstrained(i: Field): /*elided*/ any;
            set(i: UInt32 | number, value: /*elided*/ any): void;
            setOrDoNothing(i: Field, value: /*elided*/ any): void;
            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: /*elided*/ any, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[][]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                getOrUnconstrained(i: Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                    getOrUnconstrained(i: Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                        getOrUnconstrained(i: Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                            getOrUnconstrained(i: Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                getOrUnconstrained(i: Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                    getOrUnconstrained(i: Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                        getOrUnconstrained(i: Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                            getOrUnconstrained(i: Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                                getOrUnconstrained(i: Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): /*elided*/ any;
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<Field>;
                                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<Field>;
                                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<Field>;
                                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<Field>;
                                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<Field>;
                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<Field>;
                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<Field>;
                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<Field>;
                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<Field, import("o1js").Bool[]>;
                _indicesInRange: Set<Field>;
                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<Field, import("o1js").Bool[]>;
            _indicesInRange: Set<Field>;
            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[][];
            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
        };
        toReversed(): /*elided*/ any;
        slice(start: number, end: number): /*elided*/ any;
        _indexMasks: Map<Field, import("o1js").Bool[]>;
        _indicesInRange: Set<Field>;
        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
        toValue(): bigint[];
        [Symbol.iterator](): Generator<UInt64, void, unknown>;
    } | (number | bigint | UInt64)[]): {
        array: UInt64[];
        readonly innerType: Provable<UInt64, bigint>;
        readonly length: number;
        readonly maxLength: number;
        assertIndexInRange(i: UInt32 | number): void;
        get(i: UInt32 | number): UInt64;
        getOption(i: UInt32 | number): import("o1js").Option<UInt64>;
        getOrUnconstrained(i: Field): UInt64;
        set(i: UInt32 | number, value: UInt64): void;
        setOrDoNothing(i: Field, value: UInt64): void;
        map<S>(type: ProvableType<S>, f: (t: UInt64, i: number) => S): StaticArray<S, any>;
        forEach(f: (t: UInt64, i: number) => void): void;
        reduce<S>(state: S, f: (state: S, t: UInt64) => S): S;
        chunk(chunkSize: number): {
            array: /*elided*/ any[];
            readonly innerType: Provable</*elided*/ any, bigint[]>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): /*elided*/ any;
            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
            getOrUnconstrained(i: Field): /*elided*/ any;
            set(i: UInt32 | number, value: /*elided*/ any): void;
            setOrDoNothing(i: Field, value: /*elided*/ any): void;
            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: /*elided*/ any, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[][]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                getOrUnconstrained(i: Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                    getOrUnconstrained(i: Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                        getOrUnconstrained(i: Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                            getOrUnconstrained(i: Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                getOrUnconstrained(i: Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                    getOrUnconstrained(i: Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                        getOrUnconstrained(i: Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                            getOrUnconstrained(i: Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                                getOrUnconstrained(i: Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): /*elided*/ any;
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<Field>;
                                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<Field>;
                                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<Field>;
                                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<Field>;
                                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<Field>;
                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<Field>;
                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<Field>;
                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<Field>;
                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<Field, import("o1js").Bool[]>;
                _indicesInRange: Set<Field>;
                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<Field, import("o1js").Bool[]>;
            _indicesInRange: Set<Field>;
            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[][];
            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
        };
        toReversed(): /*elided*/ any;
        slice(start: number, end: number): /*elided*/ any;
        _indexMasks: Map<Field, import("o1js").Bool[]>;
        _indicesInRange: Set<Field>;
        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
        toValue(): bigint[];
        [Symbol.iterator](): Generator<UInt64, void, unknown>;
    };
}, "provable"> & {
    provable: Omit<import("o1js").ProvableHashable<{
        array: UInt64[];
        readonly innerType: Provable<UInt64, bigint>;
        readonly length: number;
        readonly maxLength: number;
        assertIndexInRange(i: UInt32 | number): void;
        get(i: UInt32 | number): UInt64;
        getOption(i: UInt32 | number): import("o1js").Option<UInt64>;
        getOrUnconstrained(i: Field): UInt64;
        set(i: UInt32 | number, value: UInt64): void;
        setOrDoNothing(i: Field, value: UInt64): void;
        map<S>(type: ProvableType<S>, f: (t: UInt64, i: number) => S): StaticArray<S, any>;
        forEach(f: (t: UInt64, i: number) => void): void;
        reduce<S>(state: S, f: (state: S, t: UInt64) => S): S;
        chunk(chunkSize: number): {
            array: /*elided*/ any[];
            readonly innerType: Provable</*elided*/ any, bigint[]>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): /*elided*/ any;
            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
            getOrUnconstrained(i: Field): /*elided*/ any;
            set(i: UInt32 | number, value: /*elided*/ any): void;
            setOrDoNothing(i: Field, value: /*elided*/ any): void;
            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: /*elided*/ any, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[][]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                getOrUnconstrained(i: Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                    getOrUnconstrained(i: Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                        getOrUnconstrained(i: Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                            getOrUnconstrained(i: Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                getOrUnconstrained(i: Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                    getOrUnconstrained(i: Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                        getOrUnconstrained(i: Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                            getOrUnconstrained(i: Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                                getOrUnconstrained(i: Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): /*elided*/ any;
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<Field>;
                                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<Field>;
                                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<Field>;
                                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<Field>;
                                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<Field>;
                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<Field>;
                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<Field>;
                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<Field>;
                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<Field, import("o1js").Bool[]>;
                _indicesInRange: Set<Field>;
                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<Field, import("o1js").Bool[]>;
            _indicesInRange: Set<Field>;
            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[][];
            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
        };
        toReversed(): /*elided*/ any;
        slice(start: number, end: number): /*elided*/ any;
        _indexMasks: Map<Field, import("o1js").Bool[]>;
        _indicesInRange: Set<Field>;
        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
        toValue(): bigint[];
        [Symbol.iterator](): Generator<UInt64, void, unknown>;
    }, bigint[]>, "fromValue"> & {
        fromValue: (value: {
            array: UInt64[];
            readonly innerType: Provable<UInt64, bigint>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): UInt64;
            getOption(i: UInt32 | number): import("o1js").Option<UInt64>;
            getOrUnconstrained(i: Field): UInt64;
            set(i: UInt32 | number, value: UInt64): void;
            setOrDoNothing(i: Field, value: UInt64): void;
            map<S>(type: ProvableType<S>, f: (t: UInt64, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: UInt64, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: UInt64) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                getOrUnconstrained(i: Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                    getOrUnconstrained(i: Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                        getOrUnconstrained(i: Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                            getOrUnconstrained(i: Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                getOrUnconstrained(i: Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                    getOrUnconstrained(i: Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                        getOrUnconstrained(i: Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                            getOrUnconstrained(i: Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                                getOrUnconstrained(i: Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): {
                                                    array: /*elided*/ any[];
                                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                    readonly length: number;
                                                    readonly maxLength: number;
                                                    assertIndexInRange(i: UInt32 | number): void;
                                                    get(i: UInt32 | number): /*elided*/ any;
                                                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                                    getOrUnconstrained(i: Field): /*elided*/ any;
                                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                    chunk(chunkSize: number): /*elided*/ any;
                                                    toReversed(): /*elided*/ any;
                                                    slice(start: number, end: number): /*elided*/ any;
                                                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                                                    _indicesInRange: Set<Field>;
                                                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                    toValue(): bigint[][][][][][][][][][][];
                                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                                };
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<Field>;
                                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<Field>;
                                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<Field>;
                                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<Field>;
                                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<Field>;
                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<Field>;
                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<Field>;
                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<Field>;
                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<Field, import("o1js").Bool[]>;
                _indicesInRange: Set<Field>;
                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<Field, import("o1js").Bool[]>;
            _indicesInRange: Set<Field>;
            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[];
            [Symbol.iterator](): Generator<UInt64, void, unknown>;
        } | (number | bigint | UInt64)[]) => {
            array: UInt64[];
            readonly innerType: Provable<UInt64, bigint>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): UInt64;
            getOption(i: UInt32 | number): import("o1js").Option<UInt64>;
            getOrUnconstrained(i: Field): UInt64;
            set(i: UInt32 | number, value: UInt64): void;
            setOrDoNothing(i: Field, value: UInt64): void;
            map<S>(type: ProvableType<S>, f: (t: UInt64, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: UInt64, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: UInt64) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                getOrUnconstrained(i: Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                    getOrUnconstrained(i: Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                        getOrUnconstrained(i: Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                            getOrUnconstrained(i: Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                getOrUnconstrained(i: Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                    getOrUnconstrained(i: Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                        getOrUnconstrained(i: Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                            getOrUnconstrained(i: Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                                getOrUnconstrained(i: Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): {
                                                    array: /*elided*/ any[];
                                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                    readonly length: number;
                                                    readonly maxLength: number;
                                                    assertIndexInRange(i: UInt32 | number): void;
                                                    get(i: UInt32 | number): /*elided*/ any;
                                                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                                    getOrUnconstrained(i: Field): /*elided*/ any;
                                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                    chunk(chunkSize: number): /*elided*/ any;
                                                    toReversed(): /*elided*/ any;
                                                    slice(start: number, end: number): /*elided*/ any;
                                                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                                                    _indicesInRange: Set<Field>;
                                                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                    toValue(): bigint[][][][][][][][][][][];
                                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                                };
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<Field>;
                                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<Field>;
                                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<Field>;
                                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<Field>;
                                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<Field>;
                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<Field>;
                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<Field>;
                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<Field>;
                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<Field, import("o1js").Bool[]>;
                _indicesInRange: Set<Field>;
                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<Field, import("o1js").Bool[]>;
            _indicesInRange: Set<Field>;
            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[];
            [Symbol.iterator](): Generator<UInt64, void, unknown>;
        };
    } & Omit<import("o1js").ProvablePure<{
        array: UInt64[];
        readonly innerType: Provable<UInt64, bigint>;
        readonly length: number;
        readonly maxLength: number;
        assertIndexInRange(i: UInt32 | number): void;
        get(i: UInt32 | number): UInt64;
        getOption(i: UInt32 | number): import("o1js").Option<UInt64>;
        getOrUnconstrained(i: Field): UInt64;
        set(i: UInt32 | number, value: UInt64): void;
        setOrDoNothing(i: Field, value: UInt64): void;
        map<S>(type: ProvableType<S>, f: (t: UInt64, i: number) => S): StaticArray<S, any>;
        forEach(f: (t: UInt64, i: number) => void): void;
        reduce<S>(state: S, f: (state: S, t: UInt64) => S): S;
        chunk(chunkSize: number): {
            array: /*elided*/ any[];
            readonly innerType: Provable</*elided*/ any, bigint[]>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): /*elided*/ any;
            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
            getOrUnconstrained(i: Field): /*elided*/ any;
            set(i: UInt32 | number, value: /*elided*/ any): void;
            setOrDoNothing(i: Field, value: /*elided*/ any): void;
            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: /*elided*/ any, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[][]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                getOrUnconstrained(i: Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                    getOrUnconstrained(i: Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                        getOrUnconstrained(i: Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                            getOrUnconstrained(i: Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                getOrUnconstrained(i: Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                    getOrUnconstrained(i: Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                        getOrUnconstrained(i: Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                            getOrUnconstrained(i: Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                                getOrUnconstrained(i: Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): /*elided*/ any;
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<Field>;
                                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<Field>;
                                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<Field>;
                                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<Field>;
                                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<Field>;
                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<Field>;
                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<Field>;
                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<Field>;
                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<Field, import("o1js").Bool[]>;
                _indicesInRange: Set<Field>;
                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<Field, import("o1js").Bool[]>;
            _indicesInRange: Set<Field>;
            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[][];
            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
        };
        toReversed(): /*elided*/ any;
        slice(start: number, end: number): /*elided*/ any;
        _indexMasks: Map<Field, import("o1js").Bool[]>;
        _indicesInRange: Set<Field>;
        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
        toValue(): bigint[];
        [Symbol.iterator](): Generator<UInt64, void, unknown>;
    }, bigint[]>, "fromValue">;
};
declare class Block64 extends Block64_base {
}
declare const State64_base: {
    new (array: UInt64[]): {
        array: UInt64[];
        readonly innerType: Provable<UInt64, bigint>;
        readonly length: number;
        readonly maxLength: number;
        assertIndexInRange(i: UInt32 | number): void;
        get(i: UInt32 | number): UInt64;
        getOption(i: UInt32 | number): import("o1js").Option<UInt64>;
        getOrUnconstrained(i: Field): UInt64;
        set(i: UInt32 | number, value: UInt64): void;
        setOrDoNothing(i: Field, value: UInt64): void;
        map<S>(type: ProvableType<S>, f: (t: UInt64, i: number) => S): StaticArray<S, any>;
        forEach(f: (t: UInt64, i: number) => void): void;
        reduce<S>(state: S, f: (state: S, t: UInt64) => S): S;
        chunk(chunkSize: number): {
            array: /*elided*/ any[];
            readonly innerType: Provable</*elided*/ any, bigint[]>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): /*elided*/ any;
            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
            getOrUnconstrained(i: Field): /*elided*/ any;
            set(i: UInt32 | number, value: /*elided*/ any): void;
            setOrDoNothing(i: Field, value: /*elided*/ any): void;
            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: /*elided*/ any, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[][]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                getOrUnconstrained(i: Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                    getOrUnconstrained(i: Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                        getOrUnconstrained(i: Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                            getOrUnconstrained(i: Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                getOrUnconstrained(i: Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                    getOrUnconstrained(i: Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                        getOrUnconstrained(i: Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                            getOrUnconstrained(i: Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                                getOrUnconstrained(i: Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): /*elided*/ any;
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<Field>;
                                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<Field>;
                                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<Field>;
                                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<Field>;
                                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<Field>;
                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<Field>;
                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<Field>;
                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<Field>;
                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<Field, import("o1js").Bool[]>;
                _indicesInRange: Set<Field>;
                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<Field, import("o1js").Bool[]>;
            _indicesInRange: Set<Field>;
            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[][];
            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
        };
        toReversed(): /*elided*/ any;
        slice(start: number, end: number): /*elided*/ any;
        _indexMasks: Map<Field, import("o1js").Bool[]>;
        _indicesInRange: Set<Field>;
        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
        toValue(): bigint[];
        [Symbol.iterator](): Generator<UInt64, void, unknown>;
    };
    readonly length: number;
} & Omit<{
    new (array: UInt64[]): {
        array: UInt64[];
        readonly innerType: Provable<UInt64, bigint>;
        readonly length: number;
        readonly maxLength: number;
        assertIndexInRange(i: UInt32 | number): void;
        get(i: UInt32 | number): UInt64;
        getOption(i: UInt32 | number): import("o1js").Option<UInt64>;
        getOrUnconstrained(i: Field): UInt64;
        set(i: UInt32 | number, value: UInt64): void;
        setOrDoNothing(i: Field, value: UInt64): void;
        map<S>(type: ProvableType<S>, f: (t: UInt64, i: number) => S): StaticArray<S, any>;
        forEach(f: (t: UInt64, i: number) => void): void;
        reduce<S>(state: S, f: (state: S, t: UInt64) => S): S;
        chunk(chunkSize: number): {
            array: /*elided*/ any[];
            readonly innerType: Provable</*elided*/ any, bigint[]>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): /*elided*/ any;
            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
            getOrUnconstrained(i: Field): /*elided*/ any;
            set(i: UInt32 | number, value: /*elided*/ any): void;
            setOrDoNothing(i: Field, value: /*elided*/ any): void;
            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: /*elided*/ any, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[][]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                getOrUnconstrained(i: Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                    getOrUnconstrained(i: Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                        getOrUnconstrained(i: Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                            getOrUnconstrained(i: Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                getOrUnconstrained(i: Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                    getOrUnconstrained(i: Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                        getOrUnconstrained(i: Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                            getOrUnconstrained(i: Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                                getOrUnconstrained(i: Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): /*elided*/ any;
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<Field>;
                                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<Field>;
                                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<Field>;
                                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<Field>;
                                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<Field>;
                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<Field>;
                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<Field>;
                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<Field>;
                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<Field, import("o1js").Bool[]>;
                _indicesInRange: Set<Field>;
                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<Field, import("o1js").Bool[]>;
            _indicesInRange: Set<Field>;
            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[][];
            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
        };
        toReversed(): /*elided*/ any;
        slice(start: number, end: number): /*elided*/ any;
        _indexMasks: Map<Field, import("o1js").Bool[]>;
        _indicesInRange: Set<Field>;
        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
        toValue(): bigint[];
        [Symbol.iterator](): Generator<UInt64, void, unknown>;
    };
    readonly length: number;
} & {
    provable: import("../o1js-missing.ts").ProvableHashableWide<{
        array: UInt64[];
        readonly innerType: Provable<UInt64, bigint>;
        readonly length: number;
        readonly maxLength: number;
        assertIndexInRange(i: UInt32 | number): void;
        get(i: UInt32 | number): UInt64;
        getOption(i: UInt32 | number): import("o1js").Option<UInt64>;
        getOrUnconstrained(i: Field): UInt64;
        set(i: UInt32 | number, value: UInt64): void;
        setOrDoNothing(i: Field, value: UInt64): void;
        map<S>(type: ProvableType<S>, f: (t: UInt64, i: number) => S): StaticArray<S, any>;
        forEach(f: (t: UInt64, i: number) => void): void;
        reduce<S>(state: S, f: (state: S, t: UInt64) => S): S;
        chunk(chunkSize: number): {
            array: /*elided*/ any[];
            readonly innerType: Provable</*elided*/ any, bigint[]>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): /*elided*/ any;
            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
            getOrUnconstrained(i: Field): /*elided*/ any;
            set(i: UInt32 | number, value: /*elided*/ any): void;
            setOrDoNothing(i: Field, value: /*elided*/ any): void;
            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: /*elided*/ any, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[][]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                getOrUnconstrained(i: Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                    getOrUnconstrained(i: Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                        getOrUnconstrained(i: Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                            getOrUnconstrained(i: Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                getOrUnconstrained(i: Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                    getOrUnconstrained(i: Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                        getOrUnconstrained(i: Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                            getOrUnconstrained(i: Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                                getOrUnconstrained(i: Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): /*elided*/ any;
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<Field>;
                                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<Field>;
                                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<Field>;
                                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<Field>;
                                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<Field>;
                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<Field>;
                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<Field>;
                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<Field>;
                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<Field, import("o1js").Bool[]>;
                _indicesInRange: Set<Field>;
                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<Field, import("o1js").Bool[]>;
            _indicesInRange: Set<Field>;
            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[][];
            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
        };
        toReversed(): /*elided*/ any;
        slice(start: number, end: number): /*elided*/ any;
        _indexMasks: Map<Field, import("o1js").Bool[]>;
        _indicesInRange: Set<Field>;
        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
        toValue(): bigint[];
        [Symbol.iterator](): Generator<UInt64, void, unknown>;
    }, bigint[], (number | bigint | UInt64)[]>;
    from(v: {
        array: UInt64[];
        readonly innerType: Provable<UInt64, bigint>;
        readonly length: number;
        readonly maxLength: number;
        assertIndexInRange(i: UInt32 | number): void;
        get(i: UInt32 | number): UInt64;
        getOption(i: UInt32 | number): import("o1js").Option<UInt64>;
        getOrUnconstrained(i: Field): UInt64;
        set(i: UInt32 | number, value: UInt64): void;
        setOrDoNothing(i: Field, value: UInt64): void;
        map<S>(type: ProvableType<S>, f: (t: UInt64, i: number) => S): StaticArray<S, any>;
        forEach(f: (t: UInt64, i: number) => void): void;
        reduce<S>(state: S, f: (state: S, t: UInt64) => S): S;
        chunk(chunkSize: number): {
            array: /*elided*/ any[];
            readonly innerType: Provable</*elided*/ any, bigint[]>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): /*elided*/ any;
            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
            getOrUnconstrained(i: Field): /*elided*/ any;
            set(i: UInt32 | number, value: /*elided*/ any): void;
            setOrDoNothing(i: Field, value: /*elided*/ any): void;
            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: /*elided*/ any, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[][]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                getOrUnconstrained(i: Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                    getOrUnconstrained(i: Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                        getOrUnconstrained(i: Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                            getOrUnconstrained(i: Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                getOrUnconstrained(i: Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                    getOrUnconstrained(i: Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                        getOrUnconstrained(i: Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                            getOrUnconstrained(i: Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                                getOrUnconstrained(i: Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): /*elided*/ any;
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<Field>;
                                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<Field>;
                                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<Field>;
                                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<Field>;
                                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<Field>;
                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<Field>;
                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<Field>;
                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<Field>;
                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<Field, import("o1js").Bool[]>;
                _indicesInRange: Set<Field>;
                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<Field, import("o1js").Bool[]>;
            _indicesInRange: Set<Field>;
            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[][];
            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
        };
        toReversed(): /*elided*/ any;
        slice(start: number, end: number): /*elided*/ any;
        _indexMasks: Map<Field, import("o1js").Bool[]>;
        _indicesInRange: Set<Field>;
        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
        toValue(): bigint[];
        [Symbol.iterator](): Generator<UInt64, void, unknown>;
    } | (number | bigint | UInt64)[]): {
        array: UInt64[];
        readonly innerType: Provable<UInt64, bigint>;
        readonly length: number;
        readonly maxLength: number;
        assertIndexInRange(i: UInt32 | number): void;
        get(i: UInt32 | number): UInt64;
        getOption(i: UInt32 | number): import("o1js").Option<UInt64>;
        getOrUnconstrained(i: Field): UInt64;
        set(i: UInt32 | number, value: UInt64): void;
        setOrDoNothing(i: Field, value: UInt64): void;
        map<S>(type: ProvableType<S>, f: (t: UInt64, i: number) => S): StaticArray<S, any>;
        forEach(f: (t: UInt64, i: number) => void): void;
        reduce<S>(state: S, f: (state: S, t: UInt64) => S): S;
        chunk(chunkSize: number): {
            array: /*elided*/ any[];
            readonly innerType: Provable</*elided*/ any, bigint[]>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): /*elided*/ any;
            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
            getOrUnconstrained(i: Field): /*elided*/ any;
            set(i: UInt32 | number, value: /*elided*/ any): void;
            setOrDoNothing(i: Field, value: /*elided*/ any): void;
            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: /*elided*/ any, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[][]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                getOrUnconstrained(i: Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                    getOrUnconstrained(i: Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                        getOrUnconstrained(i: Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                            getOrUnconstrained(i: Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                getOrUnconstrained(i: Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                    getOrUnconstrained(i: Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                        getOrUnconstrained(i: Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                            getOrUnconstrained(i: Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                                getOrUnconstrained(i: Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): /*elided*/ any;
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<Field>;
                                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<Field>;
                                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<Field>;
                                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<Field>;
                                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<Field>;
                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<Field>;
                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<Field>;
                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<Field>;
                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<Field, import("o1js").Bool[]>;
                _indicesInRange: Set<Field>;
                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<Field, import("o1js").Bool[]>;
            _indicesInRange: Set<Field>;
            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[][];
            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
        };
        toReversed(): /*elided*/ any;
        slice(start: number, end: number): /*elided*/ any;
        _indexMasks: Map<Field, import("o1js").Bool[]>;
        _indicesInRange: Set<Field>;
        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
        toValue(): bigint[];
        [Symbol.iterator](): Generator<UInt64, void, unknown>;
    };
}, "provable"> & {
    provable: Omit<import("o1js").ProvableHashable<{
        array: UInt64[];
        readonly innerType: Provable<UInt64, bigint>;
        readonly length: number;
        readonly maxLength: number;
        assertIndexInRange(i: UInt32 | number): void;
        get(i: UInt32 | number): UInt64;
        getOption(i: UInt32 | number): import("o1js").Option<UInt64>;
        getOrUnconstrained(i: Field): UInt64;
        set(i: UInt32 | number, value: UInt64): void;
        setOrDoNothing(i: Field, value: UInt64): void;
        map<S>(type: ProvableType<S>, f: (t: UInt64, i: number) => S): StaticArray<S, any>;
        forEach(f: (t: UInt64, i: number) => void): void;
        reduce<S>(state: S, f: (state: S, t: UInt64) => S): S;
        chunk(chunkSize: number): {
            array: /*elided*/ any[];
            readonly innerType: Provable</*elided*/ any, bigint[]>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): /*elided*/ any;
            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
            getOrUnconstrained(i: Field): /*elided*/ any;
            set(i: UInt32 | number, value: /*elided*/ any): void;
            setOrDoNothing(i: Field, value: /*elided*/ any): void;
            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: /*elided*/ any, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[][]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                getOrUnconstrained(i: Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                    getOrUnconstrained(i: Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                        getOrUnconstrained(i: Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                            getOrUnconstrained(i: Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                getOrUnconstrained(i: Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                    getOrUnconstrained(i: Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                        getOrUnconstrained(i: Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                            getOrUnconstrained(i: Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                                getOrUnconstrained(i: Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): /*elided*/ any;
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<Field>;
                                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<Field>;
                                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<Field>;
                                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<Field>;
                                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<Field>;
                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<Field>;
                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<Field>;
                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<Field>;
                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<Field, import("o1js").Bool[]>;
                _indicesInRange: Set<Field>;
                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<Field, import("o1js").Bool[]>;
            _indicesInRange: Set<Field>;
            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[][];
            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
        };
        toReversed(): /*elided*/ any;
        slice(start: number, end: number): /*elided*/ any;
        _indexMasks: Map<Field, import("o1js").Bool[]>;
        _indicesInRange: Set<Field>;
        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
        toValue(): bigint[];
        [Symbol.iterator](): Generator<UInt64, void, unknown>;
    }, bigint[]>, "fromValue"> & {
        fromValue: (value: {
            array: UInt64[];
            readonly innerType: Provable<UInt64, bigint>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): UInt64;
            getOption(i: UInt32 | number): import("o1js").Option<UInt64>;
            getOrUnconstrained(i: Field): UInt64;
            set(i: UInt32 | number, value: UInt64): void;
            setOrDoNothing(i: Field, value: UInt64): void;
            map<S>(type: ProvableType<S>, f: (t: UInt64, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: UInt64, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: UInt64) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                getOrUnconstrained(i: Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                    getOrUnconstrained(i: Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                        getOrUnconstrained(i: Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                            getOrUnconstrained(i: Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                getOrUnconstrained(i: Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                    getOrUnconstrained(i: Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                        getOrUnconstrained(i: Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                            getOrUnconstrained(i: Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                                getOrUnconstrained(i: Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): {
                                                    array: /*elided*/ any[];
                                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                    readonly length: number;
                                                    readonly maxLength: number;
                                                    assertIndexInRange(i: UInt32 | number): void;
                                                    get(i: UInt32 | number): /*elided*/ any;
                                                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                                    getOrUnconstrained(i: Field): /*elided*/ any;
                                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                    chunk(chunkSize: number): /*elided*/ any;
                                                    toReversed(): /*elided*/ any;
                                                    slice(start: number, end: number): /*elided*/ any;
                                                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                                                    _indicesInRange: Set<Field>;
                                                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                    toValue(): bigint[][][][][][][][][][][];
                                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                                };
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<Field>;
                                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<Field>;
                                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<Field>;
                                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<Field>;
                                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<Field>;
                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<Field>;
                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<Field>;
                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<Field>;
                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<Field, import("o1js").Bool[]>;
                _indicesInRange: Set<Field>;
                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<Field, import("o1js").Bool[]>;
            _indicesInRange: Set<Field>;
            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[];
            [Symbol.iterator](): Generator<UInt64, void, unknown>;
        } | (number | bigint | UInt64)[]) => {
            array: UInt64[];
            readonly innerType: Provable<UInt64, bigint>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): UInt64;
            getOption(i: UInt32 | number): import("o1js").Option<UInt64>;
            getOrUnconstrained(i: Field): UInt64;
            set(i: UInt32 | number, value: UInt64): void;
            setOrDoNothing(i: Field, value: UInt64): void;
            map<S>(type: ProvableType<S>, f: (t: UInt64, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: UInt64, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: UInt64) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                getOrUnconstrained(i: Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                    getOrUnconstrained(i: Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                        getOrUnconstrained(i: Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                            getOrUnconstrained(i: Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                getOrUnconstrained(i: Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                    getOrUnconstrained(i: Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                        getOrUnconstrained(i: Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                            getOrUnconstrained(i: Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                                getOrUnconstrained(i: Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): {
                                                    array: /*elided*/ any[];
                                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                    readonly length: number;
                                                    readonly maxLength: number;
                                                    assertIndexInRange(i: UInt32 | number): void;
                                                    get(i: UInt32 | number): /*elided*/ any;
                                                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                                    getOrUnconstrained(i: Field): /*elided*/ any;
                                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                    chunk(chunkSize: number): /*elided*/ any;
                                                    toReversed(): /*elided*/ any;
                                                    slice(start: number, end: number): /*elided*/ any;
                                                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                                                    _indicesInRange: Set<Field>;
                                                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                    toValue(): bigint[][][][][][][][][][][];
                                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                                };
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<Field>;
                                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<Field>;
                                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<Field>;
                                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<Field>;
                                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<Field>;
                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<Field>;
                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<Field>;
                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<Field>;
                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<Field, import("o1js").Bool[]>;
                _indicesInRange: Set<Field>;
                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<Field, import("o1js").Bool[]>;
            _indicesInRange: Set<Field>;
            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[];
            [Symbol.iterator](): Generator<UInt64, void, unknown>;
        };
    } & Omit<import("o1js").ProvablePure<{
        array: UInt64[];
        readonly innerType: Provable<UInt64, bigint>;
        readonly length: number;
        readonly maxLength: number;
        assertIndexInRange(i: UInt32 | number): void;
        get(i: UInt32 | number): UInt64;
        getOption(i: UInt32 | number): import("o1js").Option<UInt64>;
        getOrUnconstrained(i: Field): UInt64;
        set(i: UInt32 | number, value: UInt64): void;
        setOrDoNothing(i: Field, value: UInt64): void;
        map<S>(type: ProvableType<S>, f: (t: UInt64, i: number) => S): StaticArray<S, any>;
        forEach(f: (t: UInt64, i: number) => void): void;
        reduce<S>(state: S, f: (state: S, t: UInt64) => S): S;
        chunk(chunkSize: number): {
            array: /*elided*/ any[];
            readonly innerType: Provable</*elided*/ any, bigint[]>;
            readonly length: number;
            readonly maxLength: number;
            assertIndexInRange(i: UInt32 | number): void;
            get(i: UInt32 | number): /*elided*/ any;
            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
            getOrUnconstrained(i: Field): /*elided*/ any;
            set(i: UInt32 | number, value: /*elided*/ any): void;
            setOrDoNothing(i: Field, value: /*elided*/ any): void;
            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
            forEach(f: (t: /*elided*/ any, i: number) => void): void;
            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
            chunk(chunkSize: number): {
                array: /*elided*/ any[];
                readonly innerType: Provable</*elided*/ any, bigint[][]>;
                readonly length: number;
                readonly maxLength: number;
                assertIndexInRange(i: UInt32 | number): void;
                get(i: UInt32 | number): /*elided*/ any;
                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                getOrUnconstrained(i: Field): /*elided*/ any;
                set(i: UInt32 | number, value: /*elided*/ any): void;
                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                chunk(chunkSize: number): {
                    array: /*elided*/ any[];
                    readonly innerType: Provable</*elided*/ any, bigint[][][]>;
                    readonly length: number;
                    readonly maxLength: number;
                    assertIndexInRange(i: UInt32 | number): void;
                    get(i: UInt32 | number): /*elided*/ any;
                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                    getOrUnconstrained(i: Field): /*elided*/ any;
                    set(i: UInt32 | number, value: /*elided*/ any): void;
                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                    chunk(chunkSize: number): {
                        array: /*elided*/ any[];
                        readonly innerType: Provable</*elided*/ any, bigint[][][][]>;
                        readonly length: number;
                        readonly maxLength: number;
                        assertIndexInRange(i: UInt32 | number): void;
                        get(i: UInt32 | number): /*elided*/ any;
                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                        getOrUnconstrained(i: Field): /*elided*/ any;
                        set(i: UInt32 | number, value: /*elided*/ any): void;
                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                        chunk(chunkSize: number): {
                            array: /*elided*/ any[];
                            readonly innerType: Provable</*elided*/ any, bigint[][][][][]>;
                            readonly length: number;
                            readonly maxLength: number;
                            assertIndexInRange(i: UInt32 | number): void;
                            get(i: UInt32 | number): /*elided*/ any;
                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                            getOrUnconstrained(i: Field): /*elided*/ any;
                            set(i: UInt32 | number, value: /*elided*/ any): void;
                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                            chunk(chunkSize: number): {
                                array: /*elided*/ any[];
                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][]>;
                                readonly length: number;
                                readonly maxLength: number;
                                assertIndexInRange(i: UInt32 | number): void;
                                get(i: UInt32 | number): /*elided*/ any;
                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                getOrUnconstrained(i: Field): /*elided*/ any;
                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                chunk(chunkSize: number): {
                                    array: /*elided*/ any[];
                                    readonly innerType: Provable</*elided*/ any, bigint[][][][][][][]>;
                                    readonly length: number;
                                    readonly maxLength: number;
                                    assertIndexInRange(i: UInt32 | number): void;
                                    get(i: UInt32 | number): /*elided*/ any;
                                    getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                    getOrUnconstrained(i: Field): /*elided*/ any;
                                    set(i: UInt32 | number, value: /*elided*/ any): void;
                                    setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                    map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                    forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                    reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                    chunk(chunkSize: number): {
                                        array: /*elided*/ any[];
                                        readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][]>;
                                        readonly length: number;
                                        readonly maxLength: number;
                                        assertIndexInRange(i: UInt32 | number): void;
                                        get(i: UInt32 | number): /*elided*/ any;
                                        getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                        getOrUnconstrained(i: Field): /*elided*/ any;
                                        set(i: UInt32 | number, value: /*elided*/ any): void;
                                        setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                        map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                        forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                        reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                        chunk(chunkSize: number): {
                                            array: /*elided*/ any[];
                                            readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][]>;
                                            readonly length: number;
                                            readonly maxLength: number;
                                            assertIndexInRange(i: UInt32 | number): void;
                                            get(i: UInt32 | number): /*elided*/ any;
                                            getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                            getOrUnconstrained(i: Field): /*elided*/ any;
                                            set(i: UInt32 | number, value: /*elided*/ any): void;
                                            setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                            map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                            forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                            reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                            chunk(chunkSize: number): {
                                                array: /*elided*/ any[];
                                                readonly innerType: Provable</*elided*/ any, bigint[][][][][][][][][][]>;
                                                readonly length: number;
                                                readonly maxLength: number;
                                                assertIndexInRange(i: UInt32 | number): void;
                                                get(i: UInt32 | number): /*elided*/ any;
                                                getOption(i: UInt32 | number): import("o1js").Option</*elided*/ any>;
                                                getOrUnconstrained(i: Field): /*elided*/ any;
                                                set(i: UInt32 | number, value: /*elided*/ any): void;
                                                setOrDoNothing(i: Field, value: /*elided*/ any): void;
                                                map<S>(type: ProvableType<S>, f: (t: /*elided*/ any, i: number) => S): StaticArray<S, any>;
                                                forEach(f: (t: /*elided*/ any, i: number) => void): void;
                                                reduce<S>(state: S, f: (state: S, t: /*elided*/ any) => S): S;
                                                chunk(chunkSize: number): /*elided*/ any;
                                                toReversed(): /*elided*/ any;
                                                slice(start: number, end: number): /*elided*/ any;
                                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                                _indicesInRange: Set<Field>;
                                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                                toValue(): bigint[][][][][][][][][][][];
                                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                            };
                                            toReversed(): /*elided*/ any;
                                            slice(start: number, end: number): /*elided*/ any;
                                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                                            _indicesInRange: Set<Field>;
                                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                            toValue(): bigint[][][][][][][][][][];
                                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                        };
                                        toReversed(): /*elided*/ any;
                                        slice(start: number, end: number): /*elided*/ any;
                                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                                        _indicesInRange: Set<Field>;
                                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                        toValue(): bigint[][][][][][][][][];
                                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                    };
                                    toReversed(): /*elided*/ any;
                                    slice(start: number, end: number): /*elided*/ any;
                                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                                    _indicesInRange: Set<Field>;
                                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                    toValue(): bigint[][][][][][][][];
                                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                                };
                                toReversed(): /*elided*/ any;
                                slice(start: number, end: number): /*elided*/ any;
                                _indexMasks: Map<Field, import("o1js").Bool[]>;
                                _indicesInRange: Set<Field>;
                                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                                toValue(): bigint[][][][][][][];
                                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                            };
                            toReversed(): /*elided*/ any;
                            slice(start: number, end: number): /*elided*/ any;
                            _indexMasks: Map<Field, import("o1js").Bool[]>;
                            _indicesInRange: Set<Field>;
                            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                            toValue(): bigint[][][][][][];
                            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                        };
                        toReversed(): /*elided*/ any;
                        slice(start: number, end: number): /*elided*/ any;
                        _indexMasks: Map<Field, import("o1js").Bool[]>;
                        _indicesInRange: Set<Field>;
                        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                        toValue(): bigint[][][][][];
                        [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                    };
                    toReversed(): /*elided*/ any;
                    slice(start: number, end: number): /*elided*/ any;
                    _indexMasks: Map<Field, import("o1js").Bool[]>;
                    _indicesInRange: Set<Field>;
                    _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                    toValue(): bigint[][][][];
                    [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
                };
                toReversed(): /*elided*/ any;
                slice(start: number, end: number): /*elided*/ any;
                _indexMasks: Map<Field, import("o1js").Bool[]>;
                _indicesInRange: Set<Field>;
                _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
                toValue(): bigint[][][];
                [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
            };
            toReversed(): /*elided*/ any;
            slice(start: number, end: number): /*elided*/ any;
            _indexMasks: Map<Field, import("o1js").Bool[]>;
            _indicesInRange: Set<Field>;
            _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
            toValue(): bigint[][];
            [Symbol.iterator](): Generator</*elided*/ any, void, unknown>;
        };
        toReversed(): /*elided*/ any;
        slice(start: number, end: number): /*elided*/ any;
        _indexMasks: Map<Field, import("o1js").Bool[]>;
        _indicesInRange: Set<Field>;
        _indexMask(i: Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[];
        toValue(): bigint[];
        [Symbol.iterator](): Generator<UInt64, void, unknown>;
    }, bigint[]>, "fromValue">;
};
declare class State64 extends State64_base {
}
declare const Bytes28: typeof import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes;
declare const Bytes32: typeof import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes;
declare const Bytes48: typeof import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes;
declare const Bytes64: typeof import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes;
/**
 * Apply padding to dynamic-length input bytes and convert them to (a dynamic number of) blocks of 16 uint32s.
 */
declare function padding256(message: DynamicArray<UInt8>): DynamicArray<StaticArray<UInt32>, bigint[]>;
/**
 * Apply padding to dynamic-length input bytes and convert them to (a dynamic number of) blocks of 16 uint64s.
 */
declare function padding512(message: DynamicArray<UInt8>): DynamicArray<StaticArray<UInt64>>;
type Sha2IterationState<L extends Length = Length> = L extends 224 | 256 ? {
    len: L;
    state: State32;
    commitment: Field;
} : {
    len: L;
    state: State64;
    commitment: Field;
};
type Sha2Iteration<L extends Length = Length> = L extends 224 | 256 ? {
    type: 256;
    blocks: StaticArray<Block32>;
} : {
    type: 512;
    blocks: StaticArray<Block64>;
};
type Sha2FinalIteration<L extends Length = Length> = L extends 224 | 256 ? {
    type: 256;
    blocks: DynamicArray<Block32>;
} : {
    type: 512;
    blocks: DynamicArray<Block64>;
};
declare function initialState<L extends Length>(len: L): Sha2IterationState<L>;
declare function split<L extends Length>(len: L, blocksPerIteration: number, bytes: DynamicArray<UInt8>): {
    initial: Sha2IterationState<L>;
    iterations: Sha2Iteration<L>[];
    final: Sha2FinalIteration<L>;
};
declare function update<L extends Length>(iterState: Sha2IterationState<L>, iteration: Sha2Iteration): Sha2IterationState<L>;
declare function finalize(iterState: Sha2IterationState, final: Sha2FinalIteration, bytes: DynamicArray<UInt8>): Bytes;
declare function Sha2IterationState<L extends Length>(len: L): Constructor<Sha2IterationState<L>> & Provable<Sha2IterationState<L>, {
    len: L;
    state: bigint[];
    commitment: bigint;
}> & {
    initial(): Sha2IterationState<L>;
};
declare namespace Sha2IterationState {
    var initial: typeof initialState;
}
declare function Sha2Iteration<L extends Length>(len: L, blocksPerIteration: number): Constructor<Sha2Iteration<L>> & Provable<Sha2Iteration<L>, {
    type: 256 | 512;
    blocks: bigint[][];
}>;
declare function Sha2FinalIteration<L extends Length>(len: L, blocksPerIteration: number): Constructor<Sha2FinalIteration<L>> & Provable<Sha2FinalIteration<L>, {
    type: 256 | 512;
    blocks: bigint[][];
}>;
declare function hashBlock256(state: State32, block: Block32): State32;
declare function hashBlock512(state: State64, block: Block64): State64;
declare function commitBlock256(commitment: Field, block: Block32): Field;
declare function commitBlock512(commitment: Field, block: Block64): Field;