From d66e7f38ac2c088a706f6ca84d84230b9d88d9df Mon Sep 17 00:00:00 2001
From: polyprogrammist <vad.e.volodin@gmail.com>
Date: Wed, 3 Jan 2024 22:49:46 -0500
Subject: [PATCH] tmp

---
 .github/workflows/jest.yml |   18 +
 generated_test.ts          | 2562 ------------------------------------
 2 files changed, 18 insertions(+), 2562 deletions(-)
 create mode 100644 .github/workflows/jest.yml

diff --git a/.github/workflows/jest.yml b/.github/workflows/jest.yml
new file mode 100644
index 0000000..e5bb161
--- /dev/null
+++ b/.github/workflows/jest.yml
@@ -0,0 +1,18 @@
+name: GitHub Actions Demo
+run-name: ${{ github.actor }} is testing out GitHub Actions 🚀
+on: [push]
+jobs:
+  Explore-GitHub-Actions:
+    runs-on: ubuntu-latest
+    steps:
+      - run: echo "🎉 The job was automatically triggered by a ${{ github.event_name }} event."
+      - run: echo "🐧 This job is now running on a ${{ runner.os }} server hosted by GitHub!"
+      - run: echo "🔎 The name of your branch is ${{ github.ref }} and your repository is ${{ github.repository }}."
+      - name: Check out repository code
+        uses: actions/checkout@v4
+      - run: echo "💡 The ${{ github.repository }} repository has been cloned to the runner."
+      - run: echo "🖥️ The workflow is now ready to test your code on the runner."
+      - name: List files in the repository
+        run: |
+          ls ${{ github.workspace }}
+      - run: echo "🍏 This job's status is ${{ job.status }}."
\ No newline at end of file
diff --git a/generated_test.ts b/generated_test.ts
index fcee5bb..e69de29 100644
--- a/generated_test.ts
+++ b/generated_test.ts
@@ -1,2562 +0,0 @@
-import { Builder } from 'ton'
-import { Slice } from 'ton'
-import { beginCell } from 'ton'
-import { BitString } from 'ton'
-import { Cell } from 'ton'
-import { Address } from 'ton'
-export function bitLen(n: number) {
-    return n.toString(2).length;;
-}
-
-export interface Simple {
-    readonly kind: 'Simple';
-    readonly a: number;
-    readonly b: number;
-}
-
-export type TwoConstructors = TwoConstructors_bool_false | TwoConstructors_bool_true;
-
-export interface TwoConstructors_bool_false {
-    readonly kind: 'TwoConstructors_bool_false';
-    readonly a: number;
-    readonly b: number;
-    readonly c: number;
-}
-
-export interface TwoConstructors_bool_true {
-    readonly kind: 'TwoConstructors_bool_true';
-    readonly b: number;
-}
-
-export interface FixedIntParam {
-    readonly kind: 'FixedIntParam';
-    readonly y: number;
-}
-
-export interface TypedField {
-    readonly kind: 'TypedField';
-    readonly y: FixedIntParam;
-    readonly c: number;
-}
-
-export interface SharpConstructor {
-    readonly kind: 'SharpConstructor';
-    readonly y: FixedIntParam;
-    readonly c: number;
-}
-
-export type Maybe<TheType> = Maybe_nothing<TheType> | Maybe_just<TheType>;
-
-export interface Maybe_nothing<TheType> {
-    readonly kind: 'Maybe_nothing';
-}
-
-export interface Maybe_just<TheType> {
-    readonly kind: 'Maybe_just';
-    readonly value: TheType;
-}
-
-export interface TypedParam {
-    readonly kind: 'TypedParam';
-    readonly x: Maybe<SharpConstructor>;
-}
-
-export type Either<X, Y> = Either_left<X, Y> | Either_right<X, Y>;
-
-export interface Either_left<X, Y> {
-    readonly kind: 'Either_left';
-    readonly value: X;
-}
-
-export interface Either_right<X, Y> {
-    readonly kind: 'Either_right';
-    readonly value: Y;
-}
-
-export interface BitLenArg {
-    readonly kind: 'BitLenArg';
-    readonly x: number;
-    readonly value: bigint;
-}
-
-export interface BitLenArgUser {
-    readonly kind: 'BitLenArgUser';
-    readonly t: BitLenArg;
-}
-
-export interface ExprArg {
-    readonly kind: 'ExprArg';
-    readonly x: number;
-    readonly value: bigint;
-}
-
-export interface ExprArgUser {
-    readonly kind: 'ExprArgUser';
-    readonly t: ExprArg;
-}
-
-export interface ComplexTypedField {
-    readonly kind: 'ComplexTypedField';
-    readonly a: ExprArgUser;
-}
-
-export interface CellTypedField {
-    readonly kind: 'CellTypedField';
-    readonly a: ExprArgUser;
-}
-
-export interface CellsSimple {
-    readonly kind: 'CellsSimple';
-    readonly t: number;
-    readonly q: number;
-    readonly a: number;
-    readonly e: number;
-    readonly b: number;
-    readonly d: number;
-    readonly c: number;
-}
-
-export interface IntBits<Arg> {
-    readonly kind: 'IntBits';
-    readonly d: number;
-    readonly g: BitString;
-    readonly arg: Arg;
-    readonly x: Slice;
-}
-
-export interface IntBitsInside {
-    readonly kind: 'IntBitsInside';
-    readonly x: number;
-    readonly a: IntBits<bigint>;
-}
-
-export interface IntBitsOutside {
-    readonly kind: 'IntBitsOutside';
-    readonly x: IntBitsInside;
-}
-
-export interface IntBitsParametrized {
-    readonly kind: 'IntBitsParametrized';
-    readonly e: number;
-    readonly h: bigint;
-    readonly f: bigint;
-    readonly i: BitString;
-    readonly j: number;
-    readonly k: bigint;
-    readonly tc: Slice;
-}
-
-export interface IntBitsParametrizedInside {
-    readonly kind: 'IntBitsParametrizedInside';
-    readonly x: number;
-    readonly a: IntBitsParametrized;
-}
-
-export interface IntBitsParametrizedOutside {
-    readonly kind: 'IntBitsParametrizedOutside';
-    readonly x: IntBitsParametrizedInside;
-}
-
-export interface LessThan {
-    readonly kind: 'LessThan';
-    readonly x: number;
-    readonly y: number;
-}
-
-export interface OneComb<A> {
-    readonly kind: 'OneComb';
-    readonly t: number;
-    readonly x: A;
-}
-
-export interface ManyComb {
-    readonly kind: 'ManyComb';
-    readonly y: OneComb<OneComb<OneComb<number>>>;
-}
-
-export type Unary = Unary_unary_zero | Unary_unary_succ;
-
-export interface Unary_unary_zero {
-    readonly kind: 'Unary_unary_zero';
-}
-
-export interface Unary_unary_succ {
-    readonly kind: 'Unary_unary_succ';
-    readonly n: number;
-    readonly x: Unary;
-}
-
-export type ParamConst = ParamConst_b | ParamConst_c | ParamConst_a | ParamConst_d;
-
-export interface ParamConst_b {
-    readonly kind: 'ParamConst_b';
-    readonly m: number;
-    readonly k: number;
-}
-
-export interface ParamConst_c {
-    readonly kind: 'ParamConst_c';
-    readonly n: number;
-    readonly m: number;
-    readonly k: number;
-}
-
-export interface ParamConst_a {
-    readonly kind: 'ParamConst_a';
-    readonly n: number;
-}
-
-export interface ParamConst_d {
-    readonly kind: 'ParamConst_d';
-    readonly n: number;
-    readonly m: number;
-    readonly k: number;
-    readonly l: number;
-}
-
-export type ParamDifNames = ParamDifNames_a | ParamDifNames_b | ParamDifNames_c | ParamDifNames_d;
-
-export interface ParamDifNames_a {
-    readonly kind: 'ParamDifNames_a';
-}
-
-export interface ParamDifNames_b {
-    readonly kind: 'ParamDifNames_b';
-}
-
-export interface ParamDifNames_c {
-    readonly kind: 'ParamDifNames_c';
-    readonly n: number;
-    readonly x: ParamDifNames;
-}
-
-export interface ParamDifNames_d {
-    readonly kind: 'ParamDifNames_d';
-    readonly m: number;
-    readonly x: ParamDifNames;
-}
-
-export interface ParamDifNamesUser {
-    readonly kind: 'ParamDifNamesUser';
-    readonly k: number;
-    readonly x: ParamDifNames;
-}
-
-export interface NegationFromImplicit {
-    readonly kind: 'NegationFromImplicit';
-    readonly y: number;
-    readonly t: number;
-    readonly z: number;
-}
-
-export interface UnaryUserCheckOrder {
-    readonly kind: 'UnaryUserCheckOrder';
-    readonly l: number;
-    readonly m: number;
-    readonly label: Unary;
-}
-
-export interface CombArgCellRef<X> {
-    readonly kind: 'CombArgCellRef';
-    readonly info: number;
-    readonly init: Maybe<Either<X, number>>;
-    readonly other: Either<X, OneComb<X>>;
-    readonly body: Either<X, X>;
-}
-
-export interface CombArgCellRefUser {
-    readonly kind: 'CombArgCellRefUser';
-    readonly x: CombArgCellRef<number>;
-}
-
-export interface MathExprAsCombArg {
-    readonly kind: 'MathExprAsCombArg';
-    readonly n: number;
-    readonly ref: BitLenArg;
-}
-
-export interface EmptyTag {
-    readonly kind: 'EmptyTag';
-    readonly a: number;
-}
-
-export interface SharpTag {
-    readonly kind: 'SharpTag';
-    readonly x: number;
-}
-
-export interface DollarTag {
-    readonly kind: 'DollarTag';
-    readonly x: number;
-}
-
-export interface TupleCheck {
-    readonly kind: 'TupleCheck';
-    readonly s: Array<number>;
-}
-
-export interface Hashmap<X> {
-    readonly kind: 'Hashmap';
-    readonly n: number;
-    readonly l: number;
-    readonly m: number;
-    readonly label: HmLabel;
-    readonly node: HashmapNode<X>;
-}
-
-export type HashmapNode<X> = HashmapNode_hmn_leaf<X> | HashmapNode_hmn_fork<X>;
-
-export interface HashmapNode_hmn_leaf<X> {
-    readonly kind: 'HashmapNode_hmn_leaf';
-    readonly value: X;
-}
-
-export interface HashmapNode_hmn_fork<X> {
-    readonly kind: 'HashmapNode_hmn_fork';
-    readonly n: number;
-    readonly left: Hashmap<X>;
-    readonly right: Hashmap<X>;
-}
-
-export type HmLabel = HmLabel_hml_short | HmLabel_hml_long | HmLabel_hml_same;
-
-export interface HmLabel_hml_short {
-    readonly kind: 'HmLabel_hml_short';
-    readonly m: number;
-    readonly n: number;
-    readonly len: Unary;
-    readonly s: Array<BitString>;
-}
-
-export interface HmLabel_hml_long {
-    readonly kind: 'HmLabel_hml_long';
-    readonly m: number;
-    readonly n: number;
-    readonly s: Array<BitString>;
-}
-
-export interface HmLabel_hml_same {
-    readonly kind: 'HmLabel_hml_same';
-    readonly m: number;
-    readonly v: BitString;
-    readonly n: number;
-}
-
-export type HashmapE<X> = HashmapE_hme_empty<X> | HashmapE_hme_root<X>;
-
-export interface HashmapE_hme_empty<X> {
-    readonly kind: 'HashmapE_hme_empty';
-    readonly n: number;
-}
-
-export interface HashmapE_hme_root<X> {
-    readonly kind: 'HashmapE_hme_root';
-    readonly n: number;
-    readonly root: Hashmap<X>;
-}
-
-export interface HashmapEUser {
-    readonly kind: 'HashmapEUser';
-    readonly x: HashmapE<number>;
-}
-
-export interface ConditionalField {
-    readonly kind: 'ConditionalField';
-    readonly a: number;
-    readonly b: number | undefined;
-}
-
-export interface BitSelection {
-    readonly kind: 'BitSelection';
-    readonly a: number;
-    readonly b: number | undefined;
-}
-
-export interface ImplicitCondition {
-    readonly kind: 'ImplicitCondition';
-    readonly flags: number;
-}
-
-export type MultipleEmptyConstructor = MultipleEmptyConstructor__ | MultipleEmptyConstructor__1 | MultipleEmptyConstructor_a;
-
-export interface MultipleEmptyConstructor__ {
-    readonly kind: 'MultipleEmptyConstructor__';
-    readonly a: number;
-}
-
-export interface MultipleEmptyConstructor__1 {
-    readonly kind: 'MultipleEmptyConstructor__1';
-    readonly b: number;
-}
-
-export interface MultipleEmptyConstructor_a {
-    readonly kind: 'MultipleEmptyConstructor_a';
-    readonly x: number;
-}
-
-export interface True {
-    readonly kind: 'True';
-}
-
-export type ParamNamedArgInSecondConstr = ParamNamedArgInSecondConstr_a | ParamNamedArgInSecondConstr_b;
-
-export interface ParamNamedArgInSecondConstr_a {
-    readonly kind: 'ParamNamedArgInSecondConstr_a';
-    readonly n: number;
-}
-
-export interface ParamNamedArgInSecondConstr_b {
-    readonly kind: 'ParamNamedArgInSecondConstr_b';
-    readonly n: number;
-}
-
-export interface RefCombinatorAny {
-    readonly kind: 'RefCombinatorAny';
-    readonly msg: Maybe<Slice>;
-}
-
-export interface EqualityExpression {
-    readonly kind: 'EqualityExpression';
-    readonly n: number;
-}
-
-export interface ConditionalRef {
-    readonly kind: 'ConditionalRef';
-    readonly x: number;
-    readonly y: Simple | undefined;
-}
-
-export interface LoadFromNegationOutsideExpr {
-    readonly kind: 'LoadFromNegationOutsideExpr';
-    readonly prev_seq_no: number;
-    readonly seq_no: number;
-}
-
-export interface AnonymousData {
-    readonly kind: 'AnonymousData';
-    readonly anon0: number;
-    readonly anon0_0: number;
-}
-
-export interface FalseAnonField {
-    readonly kind: 'FalseAnonField';
-    readonly value: bigint;
-}
-
-export type ConstructorOrder = ConstructorOrder_a | ConstructorOrder__;
-
-export interface ConstructorOrder_a {
-    readonly kind: 'ConstructorOrder_a';
-    readonly a: Simple;
-}
-
-export interface ConstructorOrder__ {
-    readonly kind: 'ConstructorOrder__';
-    readonly anon0: Simple;
-}
-
-export type CheckCrc32 = CheckCrc32_a | CheckCrc32_b;
-
-export interface CheckCrc32_a {
-    readonly kind: 'CheckCrc32_a';
-    readonly a: number;
-}
-
-export interface CheckCrc32_b {
-    readonly kind: 'CheckCrc32_b';
-    readonly b: number;
-    readonly c: number;
-}
-
-export interface CheckKeyword {
-    readonly kind: 'CheckKeyword';
-    readonly const0: number;
-}
-
-export interface RefCombinatorInRefHelper<X> {
-    readonly kind: 'RefCombinatorInRefHelper';
-    readonly t: number;
-    readonly y: Maybe<X>;
-}
-
-export interface RefCombinatorInRef {
-    readonly kind: 'RefCombinatorInRef';
-    readonly msg: RefCombinatorInRefHelper<Slice>;
-}
-
-export interface BoolUser {
-    readonly kind: 'BoolUser';
-    readonly a: boolean;
-}
-
-export interface Anycast {
-    readonly kind: 'Anycast';
-    readonly depth: number;
-    readonly rewrite_pfx: BitString;
-}
-
-export interface AddressUser {
-    readonly kind: 'AddressUser';
-    readonly src: Address;
-}
-
-// tmpa$_ a:# b:# = Simple;
-
-export function loadSimple(slice: Slice): Simple {
-    let a: number = slice.loadUint(32);
-    let b: number = slice.loadUint(32);
-    return {
-        kind: 'Simple',
-        a: a,
-        b: b,
-    }
-
-}
-
-export function storeSimple(simple: Simple): (builder: Builder) => void {
-    return ((builder: Builder) => {
-        builder.storeUint(simple.a, 32);
-        builder.storeUint(simple.b, 32);
-    })
-
-}
-
-// bool_false$0 a:# b:(## 7) c:# = TwoConstructors;
-
-// bool_true$1 b:# = TwoConstructors;
-
-export function loadTwoConstructors(slice: Slice): TwoConstructors {
-    if (((slice.remainingBits >= 1) && (slice.preloadUint(1) == 0b0))) {
-        slice.loadUint(1);
-        let a: number = slice.loadUint(32);
-        let b: number = slice.loadUint(7);
-        let c: number = slice.loadUint(32);
-        return {
-            kind: 'TwoConstructors_bool_false',
-            a: a,
-            b: b,
-            c: c,
-        }
-
-    }
-    if (((slice.remainingBits >= 1) && (slice.preloadUint(1) == 0b1))) {
-        slice.loadUint(1);
-        let b: number = slice.loadUint(32);
-        return {
-            kind: 'TwoConstructors_bool_true',
-            b: b,
-        }
-
-    }
-    throw new Error('Expected one of "TwoConstructors_bool_false", "TwoConstructors_bool_true" in loading "TwoConstructors", but data does not satisfy any constructor');
-}
-
-export function storeTwoConstructors(twoConstructors: TwoConstructors): (builder: Builder) => void {
-    if ((twoConstructors.kind == 'TwoConstructors_bool_false')) {
-        return ((builder: Builder) => {
-            builder.storeUint(0b0, 1);
-            builder.storeUint(twoConstructors.a, 32);
-            builder.storeUint(twoConstructors.b, 7);
-            builder.storeUint(twoConstructors.c, 32);
-        })
-
-    }
-    if ((twoConstructors.kind == 'TwoConstructors_bool_true')) {
-        return ((builder: Builder) => {
-            builder.storeUint(0b1, 1);
-            builder.storeUint(twoConstructors.b, 32);
-        })
-
-    }
-    throw new Error('Expected one of "TwoConstructors_bool_false", "TwoConstructors_bool_true" in loading "TwoConstructors", but data does not satisfy any constructor');
-}
-
-// tmpb$_ y:(## 5) = FixedIntParam;
-
-export function loadFixedIntParam(slice: Slice): FixedIntParam {
-    let y: number = slice.loadUint(5);
-    return {
-        kind: 'FixedIntParam',
-        y: y,
-    }
-
-}
-
-export function storeFixedIntParam(fixedIntParam: FixedIntParam): (builder: Builder) => void {
-    return ((builder: Builder) => {
-        builder.storeUint(fixedIntParam.y, 5);
-    })
-
-}
-
-// tmpc$_ y:FixedIntParam c:# = TypedField;
-
-export function loadTypedField(slice: Slice): TypedField {
-    let y: FixedIntParam = loadFixedIntParam(slice);
-    let c: number = slice.loadUint(32);
-    return {
-        kind: 'TypedField',
-        y: y,
-        c: c,
-    }
-
-}
-
-export function storeTypedField(typedField: TypedField): (builder: Builder) => void {
-    return ((builder: Builder) => {
-        storeFixedIntParam(typedField.y)(builder);
-        builder.storeUint(typedField.c, 32);
-    })
-
-}
-
-// tmpd#_ y:FixedIntParam c:# = SharpConstructor;
-
-export function loadSharpConstructor(slice: Slice): SharpConstructor {
-    let y: FixedIntParam = loadFixedIntParam(slice);
-    let c: number = slice.loadUint(32);
-    return {
-        kind: 'SharpConstructor',
-        y: y,
-        c: c,
-    }
-
-}
-
-export function storeSharpConstructor(sharpConstructor: SharpConstructor): (builder: Builder) => void {
-    return ((builder: Builder) => {
-        storeFixedIntParam(sharpConstructor.y)(builder);
-        builder.storeUint(sharpConstructor.c, 32);
-    })
-
-}
-
-// nothing$0 {TheType:Type} = Maybe TheType;
-
-// just$1 {TheType:Type} value:TheType = Maybe TheType;
-
-export function loadMaybe<TheType>(slice: Slice, loadTheType: (slice: Slice) => TheType): Maybe<TheType> {
-    if (((slice.remainingBits >= 1) && (slice.preloadUint(1) == 0b0))) {
-        slice.loadUint(1);
-        return {
-            kind: 'Maybe_nothing',
-        }
-
-    }
-    if (((slice.remainingBits >= 1) && (slice.preloadUint(1) == 0b1))) {
-        slice.loadUint(1);
-        let value: TheType = loadTheType(slice);
-        return {
-            kind: 'Maybe_just',
-            value: value,
-        }
-
-    }
-    throw new Error('Expected one of "Maybe_nothing", "Maybe_just" in loading "Maybe", but data does not satisfy any constructor');
-}
-
-export function storeMaybe<TheType>(maybe: Maybe<TheType>, storeTheType: (theType: TheType) => (builder: Builder) => void): (builder: Builder) => void {
-    if ((maybe.kind == 'Maybe_nothing')) {
-        return ((builder: Builder) => {
-            builder.storeUint(0b0, 1);
-        })
-
-    }
-    if ((maybe.kind == 'Maybe_just')) {
-        return ((builder: Builder) => {
-            builder.storeUint(0b1, 1);
-            storeTheType(maybe.value)(builder);
-        })
-
-    }
-    throw new Error('Expected one of "Maybe_nothing", "Maybe_just" in loading "Maybe", but data does not satisfy any constructor');
-}
-
-// thejust$_ x:(Maybe SharpConstructor) = TypedParam;
-
-export function loadTypedParam(slice: Slice): TypedParam {
-    let x: Maybe<SharpConstructor> = loadMaybe<SharpConstructor>(slice, loadSharpConstructor);
-    return {
-        kind: 'TypedParam',
-        x: x,
-    }
-
-}
-
-export function storeTypedParam(typedParam: TypedParam): (builder: Builder) => void {
-    return ((builder: Builder) => {
-        storeMaybe<SharpConstructor>(typedParam.x, storeSharpConstructor)(builder);
-    })
-
-}
-
-// left$0 {X:Type} {Y:Type} value:X = Either X Y;
-
-// right$1 {X:Type} {Y:Type} value:Y = Either X Y;
-
-export function loadEither<X, Y>(slice: Slice, loadX: (slice: Slice) => X, loadY: (slice: Slice) => Y): Either<X, Y> {
-    if (((slice.remainingBits >= 1) && (slice.preloadUint(1) == 0b0))) {
-        slice.loadUint(1);
-        let value: X = loadX(slice);
-        return {
-            kind: 'Either_left',
-            value: value,
-        }
-
-    }
-    if (((slice.remainingBits >= 1) && (slice.preloadUint(1) == 0b1))) {
-        slice.loadUint(1);
-        let value: Y = loadY(slice);
-        return {
-            kind: 'Either_right',
-            value: value,
-        }
-
-    }
-    throw new Error('Expected one of "Either_left", "Either_right" in loading "Either", but data does not satisfy any constructor');
-}
-
-export function storeEither<X, Y>(either: Either<X, Y>, storeX: (x: X) => (builder: Builder) => void, storeY: (y: Y) => (builder: Builder) => void): (builder: Builder) => void {
-    if ((either.kind == 'Either_left')) {
-        return ((builder: Builder) => {
-            builder.storeUint(0b0, 1);
-            storeX(either.value)(builder);
-        })
-
-    }
-    if ((either.kind == 'Either_right')) {
-        return ((builder: Builder) => {
-            builder.storeUint(0b1, 1);
-            storeY(either.value)(builder);
-        })
-
-    }
-    throw new Error('Expected one of "Either_left", "Either_right" in loading "Either", but data does not satisfy any constructor');
-}
-
-// a$_ {x:#} value:(## x) = BitLenArg x;
-
-export function loadBitLenArg(slice: Slice, x: number): BitLenArg {
-    let value: bigint = slice.loadUintBig(x);
-    return {
-        kind: 'BitLenArg',
-        x: x,
-        value: value,
-    }
-
-}
-
-export function storeBitLenArg(bitLenArg: BitLenArg): (builder: Builder) => void {
-    return ((builder: Builder) => {
-        builder.storeUint(bitLenArg.value, bitLenArg.x);
-    })
-
-}
-
-// a$_ t:(BitLenArg 4) = BitLenArgUser;
-
-export function loadBitLenArgUser(slice: Slice): BitLenArgUser {
-    let t: BitLenArg = loadBitLenArg(slice, 4);
-    return {
-        kind: 'BitLenArgUser',
-        t: t,
-    }
-
-}
-
-export function storeBitLenArgUser(bitLenArgUser: BitLenArgUser): (builder: Builder) => void {
-    return ((builder: Builder) => {
-        storeBitLenArg(bitLenArgUser.t)(builder);
-    })
-
-}
-
-// a$_ {x:#} value:(## x) = ExprArg (2 + x);
-
-export function loadExprArg(slice: Slice, arg0: number): ExprArg {
-    let value: bigint = slice.loadUintBig((arg0 - 2));
-    return {
-        kind: 'ExprArg',
-        x: (arg0 - 2),
-        value: value,
-    }
-
-}
-
-export function storeExprArg(exprArg: ExprArg): (builder: Builder) => void {
-    return ((builder: Builder) => {
-        builder.storeUint(exprArg.value, exprArg.x);
-    })
-
-}
-
-// a$_ t:(ExprArg 6) = ExprArgUser;
-
-export function loadExprArgUser(slice: Slice): ExprArgUser {
-    let t: ExprArg = loadExprArg(slice, 6);
-    return {
-        kind: 'ExprArgUser',
-        t: t,
-    }
-
-}
-
-export function storeExprArgUser(exprArgUser: ExprArgUser): (builder: Builder) => void {
-    return ((builder: Builder) => {
-        storeExprArg(exprArgUser.t)(builder);
-    })
-
-}
-
-// a$_ a:ExprArgUser = ComplexTypedField;
-
-export function loadComplexTypedField(slice: Slice): ComplexTypedField {
-    let a: ExprArgUser = loadExprArgUser(slice);
-    return {
-        kind: 'ComplexTypedField',
-        a: a,
-    }
-
-}
-
-export function storeComplexTypedField(complexTypedField: ComplexTypedField): (builder: Builder) => void {
-    return ((builder: Builder) => {
-        storeExprArgUser(complexTypedField.a)(builder);
-    })
-
-}
-
-// a$_ a:^ExprArgUser = CellTypedField;
-
-export function loadCellTypedField(slice: Slice): CellTypedField {
-    let slice1 = slice.loadRef().beginParse();
-    let a: ExprArgUser = loadExprArgUser(slice1);
-    return {
-        kind: 'CellTypedField',
-        a: a,
-    }
-
-}
-
-export function storeCellTypedField(_cellTypedField: CellTypedField): (builder: Builder) => void {
-    return ((builder: Builder) => {
-        let cell1 = beginCell();
-        storeExprArgUser(_cellTypedField.a)(cell1);
-        builder.storeRef(cell1);
-    })
-
-}
-
-// a$_ t:# ^[ q:# ] ^[ a:(## 32) ^[ e:# ] ^[ b:(## 32) d:# ^[ c:(## 32) ] ] ] = CellsSimple;
-
-export function loadCellsSimple(slice: Slice): CellsSimple {
-    let t: number = slice.loadUint(32);
-    let slice1 = slice.loadRef().beginParse();
-    let q: number = slice1.loadUint(32);
-    let slice2 = slice.loadRef().beginParse();
-    let a: number = slice2.loadUint(32);
-    let slice21 = slice2.loadRef().beginParse();
-    let e: number = slice21.loadUint(32);
-    let slice22 = slice2.loadRef().beginParse();
-    let b: number = slice22.loadUint(32);
-    let d: number = slice22.loadUint(32);
-    let slice221 = slice22.loadRef().beginParse();
-    let c: number = slice221.loadUint(32);
-    return {
-        kind: 'CellsSimple',
-        t: t,
-        q: q,
-        a: a,
-        e: e,
-        b: b,
-        d: d,
-        c: c,
-    }
-
-}
-
-export function storeCellsSimple(_cellsSimple: CellsSimple): (builder: Builder) => void {
-    return ((builder: Builder) => {
-        builder.storeUint(_cellsSimple.t, 32);
-        let cell1 = beginCell();
-        cell1.storeUint(_cellsSimple.q, 32);
-        builder.storeRef(cell1);
-        let cell2 = beginCell();
-        cell2.storeUint(_cellsSimple.a, 32);
-        let cell21 = beginCell();
-        cell21.storeUint(_cellsSimple.e, 32);
-        cell2.storeRef(cell21);
-        let cell22 = beginCell();
-        cell22.storeUint(_cellsSimple.b, 32);
-        cell22.storeUint(_cellsSimple.d, 32);
-        let cell221 = beginCell();
-        cell221.storeUint(_cellsSimple.c, 32);
-        cell22.storeRef(cell221);
-        cell2.storeRef(cell22);
-        builder.storeRef(cell2);
-    })
-
-}
-
-// b$_ d:int11 g:bits2 {Arg:Type} arg:Arg x:Any = IntBits Arg;
-
-export function loadIntBits<Arg>(slice: Slice, loadArg: (slice: Slice) => Arg): IntBits<Arg> {
-    let d: number = slice.loadInt(11);
-    let g: BitString = slice.loadBits(2);
-    let arg: Arg = loadArg(slice);
-    let x: Slice = slice;
-    return {
-        kind: 'IntBits',
-        d: d,
-        g: g,
-        arg: arg,
-        x: x,
-    }
-
-}
-
-export function storeIntBits<Arg>(intBits: IntBits<Arg>, storeArg: (arg: Arg) => (builder: Builder) => void): (builder: Builder) => void {
-    return ((builder: Builder) => {
-        builder.storeInt(intBits.d, 11);
-        builder.storeBits(intBits.g);
-        storeArg(intBits.arg)(builder);
-        builder.storeSlice(intBits.x);
-    })
-
-}
-
-// a$_ {x:#} a:(IntBits (int (1 + x))) = IntBitsInside (x * 2);
-
-export function loadIntBitsInside(slice: Slice, arg0: number): IntBitsInside {
-    let a: IntBits<bigint> = loadIntBits<bigint>(slice, ((slice: Slice) => {
-        return slice.loadIntBig((1 + (arg0 / 2)))
-
-    }));
-    return {
-        kind: 'IntBitsInside',
-        x: (arg0 / 2),
-        a: a,
-    }
-
-}
-
-export function storeIntBitsInside(intBitsInside: IntBitsInside): (builder: Builder) => void {
-    return ((builder: Builder) => {
-        storeIntBits<bigint>(intBitsInside.a, ((arg: bigint) => {
-            return ((builder: Builder) => {
-                builder.storeInt(arg, (1 + intBitsInside.x));
-            })
-
-        }))(builder);
-    })
-
-}
-
-// a$_ x:(IntBitsInside 6) = IntBitsOutside;
-
-export function loadIntBitsOutside(slice: Slice): IntBitsOutside {
-    let x: IntBitsInside = loadIntBitsInside(slice, 6);
-    return {
-        kind: 'IntBitsOutside',
-        x: x,
-    }
-
-}
-
-export function storeIntBitsOutside(intBitsOutside: IntBitsOutside): (builder: Builder) => void {
-    return ((builder: Builder) => {
-        storeIntBitsInside(intBitsOutside.x)(builder);
-    })
-
-}
-
-// a$_ {e:#} h:(int (e * 8)) f:(uint (7 * e)) i:(bits (5 + e)) j:(int 5) k:(uint e) tc:Cell = IntBitsParametrized e;
-
-export function loadIntBitsParametrized(slice: Slice, e: number): IntBitsParametrized {
-    let h: bigint = slice.loadIntBig((e * 8));
-    let f: bigint = slice.loadUintBig((7 * e));
-    let i: BitString = slice.loadBits((5 + e));
-    let j: number = slice.loadInt(5);
-    let k: bigint = slice.loadUintBig(e);
-    let tc: Slice = slice;
-    return {
-        kind: 'IntBitsParametrized',
-        e: e,
-        h: h,
-        f: f,
-        i: i,
-        j: j,
-        k: k,
-        tc: tc,
-    }
-
-}
-
-export function storeIntBitsParametrized(intBitsParametrized: IntBitsParametrized): (builder: Builder) => void {
-    return ((builder: Builder) => {
-        builder.storeInt(intBitsParametrized.h, (intBitsParametrized.e * 8));
-        builder.storeUint(intBitsParametrized.f, (7 * intBitsParametrized.e));
-        builder.storeBits(intBitsParametrized.i);
-        builder.storeInt(intBitsParametrized.j, 5);
-        builder.storeUint(intBitsParametrized.k, intBitsParametrized.e);
-        builder.storeSlice(intBitsParametrized.tc);
-    })
-
-}
-
-// a$_ {x:#} a:(IntBitsParametrized x) = IntBitsParametrizedInside x;
-
-export function loadIntBitsParametrizedInside(slice: Slice, x: number): IntBitsParametrizedInside {
-    let a: IntBitsParametrized = loadIntBitsParametrized(slice, x);
-    return {
-        kind: 'IntBitsParametrizedInside',
-        x: x,
-        a: a,
-    }
-
-}
-
-export function storeIntBitsParametrizedInside(intBitsParametrizedInside: IntBitsParametrizedInside): (builder: Builder) => void {
-    return ((builder: Builder) => {
-        storeIntBitsParametrized(intBitsParametrizedInside.a)(builder);
-    })
-
-}
-
-// a$_ x:(IntBitsParametrizedInside 5) = IntBitsParametrizedOutside;
-
-export function loadIntBitsParametrizedOutside(slice: Slice): IntBitsParametrizedOutside {
-    let x: IntBitsParametrizedInside = loadIntBitsParametrizedInside(slice, 5);
-    return {
-        kind: 'IntBitsParametrizedOutside',
-        x: x,
-    }
-
-}
-
-export function storeIntBitsParametrizedOutside(intBitsParametrizedOutside: IntBitsParametrizedOutside): (builder: Builder) => void {
-    return ((builder: Builder) => {
-        storeIntBitsParametrizedInside(intBitsParametrizedOutside.x)(builder);
-    })
-
-}
-
-// a$_ x:(#< 4) y:(#<= 4) = LessThan;
-
-export function loadLessThan(slice: Slice): LessThan {
-    let x: number = slice.loadUint(bitLen((4 - 1)));
-    let y: number = slice.loadUint(bitLen(4));
-    return {
-        kind: 'LessThan',
-        x: x,
-        y: y,
-    }
-
-}
-
-export function storeLessThan(lessThan: LessThan): (builder: Builder) => void {
-    return ((builder: Builder) => {
-        builder.storeUint(lessThan.x, bitLen((4 - 1)));
-        builder.storeUint(lessThan.y, bitLen(4));
-    })
-
-}
-
-// a$_ {A:Type} t:# x:A = OneComb A;
-
-export function loadOneComb<A>(slice: Slice, loadA: (slice: Slice) => A): OneComb<A> {
-    let t: number = slice.loadUint(32);
-    let x: A = loadA(slice);
-    return {
-        kind: 'OneComb',
-        t: t,
-        x: x,
-    }
-
-}
-
-export function storeOneComb<A>(oneComb: OneComb<A>, storeA: (a: A) => (builder: Builder) => void): (builder: Builder) => void {
-    return ((builder: Builder) => {
-        builder.storeUint(oneComb.t, 32);
-        storeA(oneComb.x)(builder);
-    })
-
-}
-
-// a$_ y:(OneComb(OneComb(OneComb int3))) = ManyComb;
-
-export function loadManyComb(slice: Slice): ManyComb {
-    let y: OneComb<OneComb<OneComb<number>>> = loadOneComb<OneComb<OneComb<number>>>(slice, ((slice: Slice) => {
-        return loadOneComb<OneComb<number>>(slice, ((slice: Slice) => {
-            return loadOneComb<number>(slice, ((slice: Slice) => {
-                return slice.loadInt(3)
-
-            }))
-
-        }))
-
-    }));
-    return {
-        kind: 'ManyComb',
-        y: y,
-    }
-
-}
-
-export function storeManyComb(manyComb: ManyComb): (builder: Builder) => void {
-    return ((builder: Builder) => {
-        storeOneComb<OneComb<OneComb<number>>>(manyComb.y, ((arg: OneComb<OneComb<number>>) => {
-            return ((builder: Builder) => {
-                storeOneComb<OneComb<number>>(arg, ((arg: OneComb<number>) => {
-                    return ((builder: Builder) => {
-                        storeOneComb<number>(arg, ((arg: number) => {
-                            return ((builder: Builder) => {
-                                builder.storeInt(arg, 3);
-                            })
-
-                        }))(builder);
-                    })
-
-                }))(builder);
-            })
-
-        }))(builder);
-    })
-
-}
-
-// unary_zero$0 = Unary ~0;
-
-export function unary_unary_succ_get_n(x: Unary): number {
-    if ((x.kind == 'Unary_unary_zero')) {
-        return 0
-
-    }
-    if ((x.kind == 'Unary_unary_succ')) {
-        let n = x.n;
-        return (n + 1)
-
-    }
-    throw new Error('Expected one of "Unary_unary_zero", "Unary_unary_succ" for type "Unary" while getting "x", but data does not satisfy any constructor');
-}
-
-// unary_succ$1 {n:#} x:(Unary ~n) = Unary ~(n + 1);
-
-export function loadUnary(slice: Slice): Unary {
-    if (((slice.remainingBits >= 1) && (slice.preloadUint(1) == 0b0))) {
-        slice.loadUint(1);
-        return {
-            kind: 'Unary_unary_zero',
-        }
-
-    }
-    if (((slice.remainingBits >= 1) && (slice.preloadUint(1) == 0b1))) {
-        slice.loadUint(1);
-        let x: Unary = loadUnary(slice);
-        let n = unary_unary_succ_get_n(x);
-        return {
-            kind: 'Unary_unary_succ',
-            x: x,
-            n: n,
-        }
-
-    }
-    throw new Error('Expected one of "Unary_unary_zero", "Unary_unary_succ" in loading "Unary", but data does not satisfy any constructor');
-}
-
-export function storeUnary(unary: Unary): (builder: Builder) => void {
-    if ((unary.kind == 'Unary_unary_zero')) {
-        return ((builder: Builder) => {
-            builder.storeUint(0b0, 1);
-        })
-
-    }
-    if ((unary.kind == 'Unary_unary_succ')) {
-        return ((builder: Builder) => {
-            builder.storeUint(0b1, 1);
-            storeUnary(unary.x)(builder);
-        })
-
-    }
-    throw new Error('Expected one of "Unary_unary_zero", "Unary_unary_succ" in loading "Unary", but data does not satisfy any constructor');
-}
-
-// b$01 m:# k:# = ParamConst 2 1;
-
-// c$01 n:# m:# k:# = ParamConst 3 3;
-
-// a$_ n:# = ParamConst 1 1;
-
-// d$_ n:# m:# k:# l:# = ParamConst 4 2;
-
-export function loadParamConst(slice: Slice, arg0: number, arg1: number): ParamConst {
-    if (((slice.remainingBits >= 2) && ((slice.preloadUint(2) == 0b01) && ((arg0 == 2) && (arg1 == 1))))) {
-        slice.loadUint(2);
-        let m: number = slice.loadUint(32);
-        let k: number = slice.loadUint(32);
-        return {
-            kind: 'ParamConst_b',
-            m: m,
-            k: k,
-        }
-
-    }
-    if (((slice.remainingBits >= 2) && ((slice.preloadUint(2) == 0b01) && ((arg0 == 3) && (arg1 == 3))))) {
-        slice.loadUint(2);
-        let n: number = slice.loadUint(32);
-        let m: number = slice.loadUint(32);
-        let k: number = slice.loadUint(32);
-        return {
-            kind: 'ParamConst_c',
-            n: n,
-            m: m,
-            k: k,
-        }
-
-    }
-    if (((arg0 == 1) && (arg1 == 1))) {
-        let n: number = slice.loadUint(32);
-        return {
-            kind: 'ParamConst_a',
-            n: n,
-        }
-
-    }
-    if (((arg0 == 4) && (arg1 == 2))) {
-        let n: number = slice.loadUint(32);
-        let m: number = slice.loadUint(32);
-        let k: number = slice.loadUint(32);
-        let l: number = slice.loadUint(32);
-        return {
-            kind: 'ParamConst_d',
-            n: n,
-            m: m,
-            k: k,
-            l: l,
-        }
-
-    }
-    throw new Error('Expected one of "ParamConst_b", "ParamConst_c", "ParamConst_a", "ParamConst_d" in loading "ParamConst", but data does not satisfy any constructor');
-}
-
-export function storeParamConst(paramConst: ParamConst): (builder: Builder) => void {
-    if ((paramConst.kind == 'ParamConst_b')) {
-        return ((builder: Builder) => {
-            builder.storeUint(0b01, 2);
-            builder.storeUint(paramConst.m, 32);
-            builder.storeUint(paramConst.k, 32);
-        })
-
-    }
-    if ((paramConst.kind == 'ParamConst_c')) {
-        return ((builder: Builder) => {
-            builder.storeUint(0b01, 2);
-            builder.storeUint(paramConst.n, 32);
-            builder.storeUint(paramConst.m, 32);
-            builder.storeUint(paramConst.k, 32);
-        })
-
-    }
-    if ((paramConst.kind == 'ParamConst_a')) {
-        return ((builder: Builder) => {
-            builder.storeUint(paramConst.n, 32);
-        })
-
-    }
-    if ((paramConst.kind == 'ParamConst_d')) {
-        return ((builder: Builder) => {
-            builder.storeUint(paramConst.n, 32);
-            builder.storeUint(paramConst.m, 32);
-            builder.storeUint(paramConst.k, 32);
-            builder.storeUint(paramConst.l, 32);
-        })
-
-    }
-    throw new Error('Expected one of "ParamConst_b", "ParamConst_c", "ParamConst_a", "ParamConst_d" in loading "ParamConst", but data does not satisfy any constructor');
-}
-
-// a$0 = ParamDifNames 2 ~1;
-
-// b$1 = ParamDifNames 3 ~1;
-
-export function paramDifNames_c_get_n(x: ParamDifNames): number {
-    if ((x.kind == 'ParamDifNames_a')) {
-        return 1
-
-    }
-    if ((x.kind == 'ParamDifNames_b')) {
-        return 1
-
-    }
-    if ((x.kind == 'ParamDifNames_c')) {
-        let n = x.n;
-        return (n + 1)
-
-    }
-    if ((x.kind == 'ParamDifNames_d')) {
-        let m = x.m;
-        return (m * 2)
-
-    }
-    throw new Error('Expected one of "ParamDifNames_a", "ParamDifNames_b", "ParamDifNames_c", "ParamDifNames_d" for type "ParamDifNames" while getting "x", but data does not satisfy any constructor');
-}
-
-// c$1 {n:#} x:(ParamDifNames 2 ~n) = ParamDifNames 2 ~(n + 1);
-
-export function paramDifNames_d_get_m(x: ParamDifNames): number {
-    if ((x.kind == 'ParamDifNames_a')) {
-        return 1
-
-    }
-    if ((x.kind == 'ParamDifNames_b')) {
-        return 1
-
-    }
-    if ((x.kind == 'ParamDifNames_c')) {
-        let n = x.n;
-        return (n + 1)
-
-    }
-    if ((x.kind == 'ParamDifNames_d')) {
-        let m = x.m;
-        return (m * 2)
-
-    }
-    throw new Error('Expected one of "ParamDifNames_a", "ParamDifNames_b", "ParamDifNames_c", "ParamDifNames_d" for type "ParamDifNames" while getting "x", but data does not satisfy any constructor');
-}
-
-// d$0 {m:#} x:(ParamDifNames 3 ~m) = ParamDifNames 3 ~(m * 2);
-
-export function loadParamDifNames(slice: Slice, arg0: number): ParamDifNames {
-    if (((slice.remainingBits >= 1) && ((slice.preloadUint(1) == 0b0) && (arg0 == 2)))) {
-        slice.loadUint(1);
-        return {
-            kind: 'ParamDifNames_a',
-        }
-
-    }
-    if (((slice.remainingBits >= 1) && ((slice.preloadUint(1) == 0b1) && (arg0 == 3)))) {
-        slice.loadUint(1);
-        return {
-            kind: 'ParamDifNames_b',
-        }
-
-    }
-    if (((slice.remainingBits >= 1) && ((slice.preloadUint(1) == 0b1) && (arg0 == 2)))) {
-        slice.loadUint(1);
-        let x: ParamDifNames = loadParamDifNames(slice, 2);
-        let n = paramDifNames_c_get_n(x);
-        return {
-            kind: 'ParamDifNames_c',
-            x: x,
-            n: n,
-        }
-
-    }
-    if (((slice.remainingBits >= 1) && ((slice.preloadUint(1) == 0b0) && (arg0 == 3)))) {
-        slice.loadUint(1);
-        let x: ParamDifNames = loadParamDifNames(slice, 3);
-        let m = paramDifNames_d_get_m(x);
-        return {
-            kind: 'ParamDifNames_d',
-            x: x,
-            m: m,
-        }
-
-    }
-    throw new Error('Expected one of "ParamDifNames_a", "ParamDifNames_b", "ParamDifNames_c", "ParamDifNames_d" in loading "ParamDifNames", but data does not satisfy any constructor');
-}
-
-export function storeParamDifNames(paramDifNames: ParamDifNames): (builder: Builder) => void {
-    if ((paramDifNames.kind == 'ParamDifNames_a')) {
-        return ((builder: Builder) => {
-            builder.storeUint(0b0, 1);
-        })
-
-    }
-    if ((paramDifNames.kind == 'ParamDifNames_b')) {
-        return ((builder: Builder) => {
-            builder.storeUint(0b1, 1);
-        })
-
-    }
-    if ((paramDifNames.kind == 'ParamDifNames_c')) {
-        return ((builder: Builder) => {
-            builder.storeUint(0b1, 1);
-            storeParamDifNames(paramDifNames.x)(builder);
-        })
-
-    }
-    if ((paramDifNames.kind == 'ParamDifNames_d')) {
-        return ((builder: Builder) => {
-            builder.storeUint(0b0, 1);
-            storeParamDifNames(paramDifNames.x)(builder);
-        })
-
-    }
-    throw new Error('Expected one of "ParamDifNames_a", "ParamDifNames_b", "ParamDifNames_c", "ParamDifNames_d" in loading "ParamDifNames", but data does not satisfy any constructor');
-}
-
-export function paramDifNamesUser_get_k(x: ParamDifNames): number {
-    if ((x.kind == 'ParamDifNames_a')) {
-        return 1
-
-    }
-    if ((x.kind == 'ParamDifNames_b')) {
-        return 1
-
-    }
-    if ((x.kind == 'ParamDifNames_c')) {
-        let n = x.n;
-        return (n + 1)
-
-    }
-    if ((x.kind == 'ParamDifNames_d')) {
-        let m = x.m;
-        return (m * 2)
-
-    }
-    throw new Error('Expected one of "ParamDifNames_a", "ParamDifNames_b", "ParamDifNames_c", "ParamDifNames_d" for type "ParamDifNames" while getting "x", but data does not satisfy any constructor');
-}
-
-// e$0 {k:#} x:(ParamDifNames 2 ~k) = ParamDifNamesUser;
-
-export function loadParamDifNamesUser(slice: Slice): ParamDifNamesUser {
-    if (((slice.remainingBits >= 1) && (slice.preloadUint(1) == 0b0))) {
-        slice.loadUint(1);
-        let x: ParamDifNames = loadParamDifNames(slice, 2);
-        let k = paramDifNamesUser_get_k(x);
-        return {
-            kind: 'ParamDifNamesUser',
-            x: x,
-            k: k,
-        }
-
-    }
-    throw new Error('Expected one of "ParamDifNamesUser" in loading "ParamDifNamesUser", but data does not satisfy any constructor');
-}
-
-export function storeParamDifNamesUser(paramDifNamesUser: ParamDifNamesUser): (builder: Builder) => void {
-    return ((builder: Builder) => {
-        builder.storeUint(0b0, 1);
-        storeParamDifNames(paramDifNamesUser.x)(builder);
-    })
-
-}
-
-// b$1 {y:#} t:# z:# { t = (~y) * 2} = NegationFromImplicit ~(y + 1);
-
-export function loadNegationFromImplicit(slice: Slice): NegationFromImplicit {
-    if (((slice.remainingBits >= 1) && (slice.preloadUint(1) == 0b1))) {
-        slice.loadUint(1);
-        let t: number = slice.loadUint(32);
-        let z: number = slice.loadUint(32);
-        return {
-            kind: 'NegationFromImplicit',
-            y: (t / 2),
-            t: t,
-            z: z,
-        }
-
-    }
-    throw new Error('Expected one of "NegationFromImplicit" in loading "NegationFromImplicit", but data does not satisfy any constructor');
-}
-
-export function storeNegationFromImplicit(negationFromImplicit: NegationFromImplicit): (builder: Builder) => void {
-    return ((builder: Builder) => {
-        builder.storeUint(0b1, 1);
-        builder.storeUint(negationFromImplicit.t, 32);
-        builder.storeUint(negationFromImplicit.z, 32);
-    })
-
-}
-
-export function unaryUserCheckOrder_get_l(label: Unary): number {
-    if ((label.kind == 'Unary_unary_zero')) {
-        return 0
-
-    }
-    if ((label.kind == 'Unary_unary_succ')) {
-        let n = label.n;
-        return (n + 1)
-
-    }
-    throw new Error('Expected one of "Unary_unary_zero", "Unary_unary_succ" for type "Unary" while getting "label", but data does not satisfy any constructor');
-}
-
-// hm_edge#_ {l:#} {m:#} label:(Unary ~l) {7 = (~m) + l} = UnaryUserCheckOrder;
-
-export function loadUnaryUserCheckOrder(slice: Slice): UnaryUserCheckOrder {
-    let label: Unary = loadUnary(slice);
-    let l = unaryUserCheckOrder_get_l(label);
-    return {
-        kind: 'UnaryUserCheckOrder',
-        m: (7 - l),
-        label: label,
-        l: l,
-    }
-
-}
-
-export function storeUnaryUserCheckOrder(unaryUserCheckOrder: UnaryUserCheckOrder): (builder: Builder) => void {
-    return ((builder: Builder) => {
-        storeUnary(unaryUserCheckOrder.label)(builder);
-    })
-
-}
-
-/*
-a$_ {X:Type} info:int32
-  init:(Maybe (Either X ^int22))
-  other:(Either X ^(OneComb X))
-  body:(Either X ^X) = CombArgCellRef X;
-*/
-
-export function loadCombArgCellRef<X>(slice: Slice, loadX: (slice: Slice) => X): CombArgCellRef<X> {
-    let info: number = slice.loadInt(32);
-    let init: Maybe<Either<X, number>> = loadMaybe<Either<X, number>>(slice, ((slice: Slice) => {
-        return loadEither<X, number>(slice, loadX, ((slice: Slice) => {
-            let slice1 = slice.loadRef().beginParse();
-            return slice1.loadInt(22)
-
-        }))
-
-    }));
-    let other: Either<X, OneComb<X>> = loadEither<X, OneComb<X>>(slice, loadX, ((slice: Slice) => {
-        let slice1 = slice.loadRef().beginParse();
-        return loadOneComb<X>(slice1, loadX)
-
-    }));
-    let body: Either<X, X> = loadEither<X, X>(slice, loadX, ((slice: Slice) => {
-        let slice1 = slice.loadRef().beginParse();
-        return loadX(slice1)
-
-    }));
-    return {
-        kind: 'CombArgCellRef',
-        info: info,
-        init: init,
-        other: other,
-        body: body,
-    }
-
-}
-
-export function storeCombArgCellRef<X>(combArgCellRef: CombArgCellRef<X>, storeX: (x: X) => (builder: Builder) => void): (builder: Builder) => void {
-    return ((builder: Builder) => {
-        builder.storeInt(combArgCellRef.info, 32);
-        storeMaybe<Either<X, number>>(combArgCellRef.init, ((arg: Either<X, number>) => {
-            return ((builder: Builder) => {
-                storeEither<X, number>(arg, storeX, ((arg: number) => {
-                    return ((builder: Builder) => {
-                        let cell1 = beginCell();
-                        cell1.storeInt(arg, 22);
-                        builder.storeRef(cell1);
-
-                    })
-
-                }))(builder);
-            })
-
-        }))(builder);
-        storeEither<X, OneComb<X>>(combArgCellRef.other, storeX, ((arg: OneComb<X>) => {
-            return ((builder: Builder) => {
-                let cell1 = beginCell();
-                storeOneComb<X>(arg, storeX)(cell1);
-                builder.storeRef(cell1);
-
-            })
-
-        }))(builder);
-        storeEither<X, X>(combArgCellRef.body, storeX, ((arg: X) => {
-            return ((builder: Builder) => {
-                let cell1 = beginCell();
-                storeX(arg)(cell1);
-                builder.storeRef(cell1);
-
-            })
-
-        }))(builder);
-    })
-
-}
-
-// a$_ x:(CombArgCellRef int12) = CombArgCellRefUser;
-
-export function loadCombArgCellRefUser(slice: Slice): CombArgCellRefUser {
-    let x: CombArgCellRef<number> = loadCombArgCellRef<number>(slice, ((slice: Slice) => {
-        return slice.loadInt(12)
-
-    }));
-    return {
-        kind: 'CombArgCellRefUser',
-        x: x,
-    }
-
-}
-
-export function storeCombArgCellRefUser(combArgCellRefUser: CombArgCellRefUser): (builder: Builder) => void {
-    return ((builder: Builder) => {
-        storeCombArgCellRef<number>(combArgCellRefUser.x, ((arg: number) => {
-            return ((builder: Builder) => {
-                builder.storeInt(arg, 12);
-            })
-
-        }))(builder);
-    })
-
-}
-
-// a$_ {n:#} ref:^(BitLenArg (n + 2)) = MathExprAsCombArg (n + 2);
-
-export function loadMathExprAsCombArg(slice: Slice, arg0: number): MathExprAsCombArg {
-    let slice1 = slice.loadRef().beginParse();
-    let ref: BitLenArg = loadBitLenArg(slice1, ((arg0 - 2) + 2));
-    return {
-        kind: 'MathExprAsCombArg',
-        n: (arg0 - 2),
-        ref: ref,
-    }
-
-}
-
-export function storeMathExprAsCombArg(mathExprAsCombArg: MathExprAsCombArg): (builder: Builder) => void {
-    return ((builder: Builder) => {
-        let cell1 = beginCell();
-        storeBitLenArg(mathExprAsCombArg.ref)(cell1);
-        builder.storeRef(cell1);
-    })
-
-}
-
-// _ a:# = EmptyTag;
-
-export function loadEmptyTag(slice: Slice): EmptyTag {
-    let a: number = slice.loadUint(32);
-    return {
-        kind: 'EmptyTag',
-        a: a,
-    }
-
-}
-
-export function storeEmptyTag(emptyTag: EmptyTag): (builder: Builder) => void {
-    return ((builder: Builder) => {
-        builder.storeUint(emptyTag.a, 32);
-    })
-
-}
-
-// a#f4 x:# = SharpTag;
-
-export function loadSharpTag(slice: Slice): SharpTag {
-    if (((slice.remainingBits >= 8) && (slice.preloadUint(8) == 0xf4))) {
-        slice.loadUint(8);
-        let x: number = slice.loadUint(32);
-        return {
-            kind: 'SharpTag',
-            x: x,
-        }
-
-    }
-    throw new Error('Expected one of "SharpTag" in loading "SharpTag", but data does not satisfy any constructor');
-}
-
-export function storeSharpTag(sharpTag: SharpTag): (builder: Builder) => void {
-    return ((builder: Builder) => {
-        builder.storeUint(0xf4, 8);
-        builder.storeUint(sharpTag.x, 32);
-    })
-
-}
-
-// a$1011 x:# = DollarTag;
-
-export function loadDollarTag(slice: Slice): DollarTag {
-    if (((slice.remainingBits >= 4) && (slice.preloadUint(4) == 0b1011))) {
-        slice.loadUint(4);
-        let x: number = slice.loadUint(32);
-        return {
-            kind: 'DollarTag',
-            x: x,
-        }
-
-    }
-    throw new Error('Expected one of "DollarTag" in loading "DollarTag", but data does not satisfy any constructor');
-}
-
-export function storeDollarTag(dollarTag: DollarTag): (builder: Builder) => void {
-    return ((builder: Builder) => {
-        builder.storeUint(0b1011, 4);
-        builder.storeUint(dollarTag.x, 32);
-    })
-
-}
-
-// a$_ s:(3 * int5) = TupleCheck;
-
-export function loadTupleCheck(slice: Slice): TupleCheck {
-    let s: Array<number> = Array.from(Array(3).keys()).map(((arg: number) => {
-        return slice.loadInt(5)
-
-    }));
-    return {
-        kind: 'TupleCheck',
-        s: s,
-    }
-
-}
-
-export function storeTupleCheck(tupleCheck: TupleCheck): (builder: Builder) => void {
-    return ((builder: Builder) => {
-        tupleCheck.s.forEach(((arg: number) => {
-            builder.storeInt(arg, 5);
-        }));
-    })
-
-}
-
-export function hashmap_get_l(label: HmLabel): number {
-    if ((label.kind == 'HmLabel_hml_short')) {
-        let n = label.n;
-        return n
-
-    }
-    if ((label.kind == 'HmLabel_hml_long')) {
-        let n = label.n;
-        return n
-
-    }
-    if ((label.kind == 'HmLabel_hml_same')) {
-        let n = label.n;
-        return n
-
-    }
-    throw new Error('Expected one of "HmLabel_hml_short", "HmLabel_hml_long", "HmLabel_hml_same" for type "HmLabel" while getting "label", but data does not satisfy any constructor');
-}
-
-/*
-hm_edge#_ {n:#} {X:Type} {l:#} {m:#} label:(HmLabel ~l n) 
-          {n = (~m) + l} node:(HashmapNode m X) = Hashmap n X;
-*/
-
-export function loadHashmap<X>(slice: Slice, n: number, loadX: (slice: Slice) => X): Hashmap<X> {
-    let label: HmLabel = loadHmLabel(slice, n);
-    let l = hashmap_get_l(label);
-    let node: HashmapNode<X> = loadHashmapNode<X>(slice, (n - l), loadX);
-    return {
-        kind: 'Hashmap',
-        n: n,
-        m: (n - l),
-        label: label,
-        l: l,
-        node: node,
-    }
-
-}
-
-export function storeHashmap<X>(hashmap: Hashmap<X>, storeX: (x: X) => (builder: Builder) => void): (builder: Builder) => void {
-    return ((builder: Builder) => {
-        storeHmLabel(hashmap.label)(builder);
-        storeHashmapNode<X>(hashmap.node, storeX)(builder);
-    })
-
-}
-
-// hmn_leaf#_ {X:Type} value:X = HashmapNode 0 X;
-
-/*
-hmn_fork#_ {n:#} {X:Type} left:^(Hashmap n X) 
-           right:^(Hashmap n X) = HashmapNode (n + 1) X;
-*/
-
-export function loadHashmapNode<X>(slice: Slice, arg0: number, loadX: (slice: Slice) => X): HashmapNode<X> {
-    if ((arg0 == 0)) {
-        let value: X = loadX(slice);
-        return {
-            kind: 'HashmapNode_hmn_leaf',
-            value: value,
-        }
-
-    }
-    if (true) {
-        let slice1 = slice.loadRef().beginParse();
-        let left: Hashmap<X> = loadHashmap<X>(slice1, (arg0 - 1), loadX);
-        let slice2 = slice.loadRef().beginParse();
-        let right: Hashmap<X> = loadHashmap<X>(slice2, (arg0 - 1), loadX);
-        return {
-            kind: 'HashmapNode_hmn_fork',
-            n: (arg0 - 1),
-            left: left,
-            right: right,
-        }
-
-    }
-    throw new Error('Expected one of "HashmapNode_hmn_leaf", "HashmapNode_hmn_fork" in loading "HashmapNode", but data does not satisfy any constructor');
-}
-
-export function storeHashmapNode<X>(hashmapNode: HashmapNode<X>, storeX: (x: X) => (builder: Builder) => void): (builder: Builder) => void {
-    if ((hashmapNode.kind == 'HashmapNode_hmn_leaf')) {
-        return ((builder: Builder) => {
-            storeX(hashmapNode.value)(builder);
-        })
-
-    }
-    if ((hashmapNode.kind == 'HashmapNode_hmn_fork')) {
-        return ((builder: Builder) => {
-            let cell1 = beginCell();
-            storeHashmap<X>(hashmapNode.left, storeX)(cell1);
-            builder.storeRef(cell1);
-            let cell2 = beginCell();
-            storeHashmap<X>(hashmapNode.right, storeX)(cell2);
-            builder.storeRef(cell2);
-        })
-
-    }
-    throw new Error('Expected one of "HashmapNode_hmn_leaf", "HashmapNode_hmn_fork" in loading "HashmapNode", but data does not satisfy any constructor');
-}
-
-export function hmLabel_hml_short_get_n(len: Unary): number {
-    if ((len.kind == 'Unary_unary_zero')) {
-        return 0
-
-    }
-    if ((len.kind == 'Unary_unary_succ')) {
-        let n = len.n;
-        return (n + 1)
-
-    }
-    throw new Error('Expected one of "Unary_unary_zero", "Unary_unary_succ" for type "Unary" while getting "len", but data does not satisfy any constructor');
-}
-
-// hml_short$0 {m:#} {n:#} len:(Unary ~n) {n <= m} s:(n * Bit) = HmLabel ~n m;
-
-// hml_long$10 {m:#} n:(#<= m) s:(n * Bit) = HmLabel ~n m;
-
-// hml_same$11 {m:#} v:Bit n:(#<= m) = HmLabel ~n m;
-
-export function loadHmLabel(slice: Slice, m: number): HmLabel {
-    if (((slice.remainingBits >= 1) && (slice.preloadUint(1) == 0b0))) {
-        slice.loadUint(1);
-        let len: Unary = loadUnary(slice);
-        let n = hmLabel_hml_short_get_n(len);
-        let s: Array<BitString> = Array.from(Array(n).keys()).map(((arg: number) => {
-            return slice.loadBits(1)
-
-        }));
-        if ((!(n <= m))) {
-            throw new Error('Condition (n <= m) is not satisfied while loading "HmLabel_hml_short" for type "HmLabel"');
-        }
-        return {
-            kind: 'HmLabel_hml_short',
-            m: m,
-            len: len,
-            n: n,
-            s: s,
-        }
-
-    }
-    if (((slice.remainingBits >= 2) && (slice.preloadUint(2) == 0b10))) {
-        slice.loadUint(2);
-        let n: number = slice.loadUint(bitLen(m));
-        let s: Array<BitString> = Array.from(Array(n).keys()).map(((arg: number) => {
-            return slice.loadBits(1)
-
-        }));
-        return {
-            kind: 'HmLabel_hml_long',
-            m: m,
-            n: n,
-            s: s,
-        }
-
-    }
-    if (((slice.remainingBits >= 2) && (slice.preloadUint(2) == 0b11))) {
-        slice.loadUint(2);
-        let v: BitString = slice.loadBits(1);
-        let n: number = slice.loadUint(bitLen(m));
-        return {
-            kind: 'HmLabel_hml_same',
-            m: m,
-            v: v,
-            n: n,
-        }
-
-    }
-    throw new Error('Expected one of "HmLabel_hml_short", "HmLabel_hml_long", "HmLabel_hml_same" in loading "HmLabel", but data does not satisfy any constructor');
-}
-
-export function storeHmLabel(hmLabel: HmLabel): (builder: Builder) => void {
-    if ((hmLabel.kind == 'HmLabel_hml_short')) {
-        return ((builder: Builder) => {
-            builder.storeUint(0b0, 1);
-            storeUnary(hmLabel.len)(builder);
-            hmLabel.s.forEach(((arg: BitString) => {
-                builder.storeBits(arg);
-            }));
-            if ((!(hmLabel.n <= hmLabel.m))) {
-                throw new Error('Condition (hmLabel.n <= hmLabel.m) is not satisfied while loading "HmLabel_hml_short" for type "HmLabel"');
-            }
-        })
-
-    }
-    if ((hmLabel.kind == 'HmLabel_hml_long')) {
-        return ((builder: Builder) => {
-            builder.storeUint(0b10, 2);
-            builder.storeUint(hmLabel.n, bitLen(hmLabel.m));
-            hmLabel.s.forEach(((arg: BitString) => {
-                builder.storeBits(arg);
-            }));
-        })
-
-    }
-    if ((hmLabel.kind == 'HmLabel_hml_same')) {
-        return ((builder: Builder) => {
-            builder.storeUint(0b11, 2);
-            builder.storeBits(hmLabel.v);
-            builder.storeUint(hmLabel.n, bitLen(hmLabel.m));
-        })
-
-    }
-    throw new Error('Expected one of "HmLabel_hml_short", "HmLabel_hml_long", "HmLabel_hml_same" in loading "HmLabel", but data does not satisfy any constructor');
-}
-
-// hme_empty$0 {n:#} {X:Type} = HashmapE n X;
-
-// hme_root$1 {n:#} {X:Type} root:^(Hashmap n X) = HashmapE n X;
-
-export function loadHashmapE<X>(slice: Slice, n: number, loadX: (slice: Slice) => X): HashmapE<X> {
-    if (((slice.remainingBits >= 1) && (slice.preloadUint(1) == 0b0))) {
-        slice.loadUint(1);
-        return {
-            kind: 'HashmapE_hme_empty',
-            n: n,
-        }
-
-    }
-    if (((slice.remainingBits >= 1) && (slice.preloadUint(1) == 0b1))) {
-        slice.loadUint(1);
-        let slice1 = slice.loadRef().beginParse();
-        let root: Hashmap<X> = loadHashmap<X>(slice1, n, loadX);
-        return {
-            kind: 'HashmapE_hme_root',
-            n: n,
-            root: root,
-        }
-
-    }
-    throw new Error('Expected one of "HashmapE_hme_empty", "HashmapE_hme_root" in loading "HashmapE", but data does not satisfy any constructor');
-}
-
-export function storeHashmapE<X>(hashmapE: HashmapE<X>, storeX: (x: X) => (builder: Builder) => void): (builder: Builder) => void {
-    if ((hashmapE.kind == 'HashmapE_hme_empty')) {
-        return ((builder: Builder) => {
-            builder.storeUint(0b0, 1);
-        })
-
-    }
-    if ((hashmapE.kind == 'HashmapE_hme_root')) {
-        return ((builder: Builder) => {
-            builder.storeUint(0b1, 1);
-            let cell1 = beginCell();
-            storeHashmap<X>(hashmapE.root, storeX)(cell1);
-            builder.storeRef(cell1);
-        })
-
-    }
-    throw new Error('Expected one of "HashmapE_hme_empty", "HashmapE_hme_root" in loading "HashmapE", but data does not satisfy any constructor');
-}
-
-// a$_ x:(HashmapE 8 uint16) = HashmapEUser;
-
-export function loadHashmapEUser(slice: Slice): HashmapEUser {
-    let x: HashmapE<number> = loadHashmapE<number>(slice, 8, ((slice: Slice) => {
-        return slice.loadUint(16)
-
-    }));
-    return {
-        kind: 'HashmapEUser',
-        x: x,
-    }
-
-}
-
-export function storeHashmapEUser(hashmapEUser: HashmapEUser): (builder: Builder) => void {
-    return ((builder: Builder) => {
-        storeHashmapE<number>(hashmapEUser.x, ((arg: number) => {
-            return ((builder: Builder) => {
-                builder.storeUint(arg, 16);
-            })
-
-        }))(builder);
-    })
-
-}
-
-// _ a:(## 1) b:a?(## 32) = ConditionalField;
-
-export function loadConditionalField(slice: Slice): ConditionalField {
-    let a: number = slice.loadUint(1);
-    let b: number | undefined = (a ? slice.loadUint(32) : undefined);
-    return {
-        kind: 'ConditionalField',
-        a: a,
-        b: b,
-    }
-
-}
-
-export function storeConditionalField(conditionalField: ConditionalField): (builder: Builder) => void {
-    return ((builder: Builder) => {
-        builder.storeUint(conditionalField.a, 1);
-        if ((conditionalField.b != undefined)) {
-            builder.storeUint(conditionalField.b, 32);
-        }
-    })
-
-}
-
-// _ a:(## 6) b:(a . 2)?(## 32) = BitSelection;
-
-export function loadBitSelection(slice: Slice): BitSelection {
-    let a: number = slice.loadUint(6);
-    let b: number | undefined = ((a & (1 << 2)) ? slice.loadUint(32) : undefined);
-    return {
-        kind: 'BitSelection',
-        a: a,
-        b: b,
-    }
-
-}
-
-export function storeBitSelection(bitSelection: BitSelection): (builder: Builder) => void {
-    return ((builder: Builder) => {
-        builder.storeUint(bitSelection.a, 6);
-        if ((bitSelection.b != undefined)) {
-            builder.storeUint(bitSelection.b, 32);
-        }
-    })
-
-}
-
-// _ flags:(## 10) { flags <= 100 } = ImplicitCondition;
-
-export function loadImplicitCondition(slice: Slice): ImplicitCondition {
-    let flags: number = slice.loadUint(10);
-    if ((!(flags <= 100))) {
-        throw new Error('Condition (flags <= 100) is not satisfied while loading "ImplicitCondition" for type "ImplicitCondition"');
-    }
-    return {
-        kind: 'ImplicitCondition',
-        flags: flags,
-    }
-
-}
-
-export function storeImplicitCondition(implicitCondition: ImplicitCondition): (builder: Builder) => void {
-    return ((builder: Builder) => {
-        builder.storeUint(implicitCondition.flags, 10);
-        if ((!(implicitCondition.flags <= 100))) {
-            throw new Error('Condition (implicitCondition.flags <= 100) is not satisfied while loading "ImplicitCondition" for type "ImplicitCondition"');
-        }
-    })
-
-}
-
-// _ a:# = MultipleEmptyConstructor 0;
-
-// _ b:(## 5) = MultipleEmptyConstructor 1;
-
-// a$_ x:(## 6) = MultipleEmptyConstructor 2;
-
-export function loadMultipleEmptyConstructor(slice: Slice, arg0: number): MultipleEmptyConstructor {
-    if ((arg0 == 0)) {
-        let a: number = slice.loadUint(32);
-        return {
-            kind: 'MultipleEmptyConstructor__',
-            a: a,
-        }
-
-    }
-    if ((arg0 == 1)) {
-        let b: number = slice.loadUint(5);
-        return {
-            kind: 'MultipleEmptyConstructor__1',
-            b: b,
-        }
-
-    }
-    if ((arg0 == 2)) {
-        let x: number = slice.loadUint(6);
-        return {
-            kind: 'MultipleEmptyConstructor_a',
-            x: x,
-        }
-
-    }
-    throw new Error('Expected one of "MultipleEmptyConstructor__", "MultipleEmptyConstructor__1", "MultipleEmptyConstructor_a" in loading "MultipleEmptyConstructor", but data does not satisfy any constructor');
-}
-
-export function storeMultipleEmptyConstructor(multipleEmptyConstructor: MultipleEmptyConstructor): (builder: Builder) => void {
-    if ((multipleEmptyConstructor.kind == 'MultipleEmptyConstructor__')) {
-        return ((builder: Builder) => {
-            builder.storeUint(multipleEmptyConstructor.a, 32);
-        })
-
-    }
-    if ((multipleEmptyConstructor.kind == 'MultipleEmptyConstructor__1')) {
-        return ((builder: Builder) => {
-            builder.storeUint(multipleEmptyConstructor.b, 5);
-        })
-
-    }
-    if ((multipleEmptyConstructor.kind == 'MultipleEmptyConstructor_a')) {
-        return ((builder: Builder) => {
-            builder.storeUint(multipleEmptyConstructor.x, 6);
-        })
-
-    }
-    throw new Error('Expected one of "MultipleEmptyConstructor__", "MultipleEmptyConstructor__1", "MultipleEmptyConstructor_a" in loading "MultipleEmptyConstructor", but data does not satisfy any constructor');
-}
-
-// true$_ = True;
-
-export function loadTrue(slice: Slice): True {
-    return {
-        kind: 'True',
-    }
-
-}
-
-export function storeTrue(true0: True): (builder: Builder) => void {
-    return ((builder: Builder) => {
-    })
-
-}
-
-// a$0 {n:#} = ParamNamedArgInSecondConstr n;
-
-// b$1 {n:#} = ParamNamedArgInSecondConstr (n + 1);
-
-export function loadParamNamedArgInSecondConstr(slice: Slice, arg0: number): ParamNamedArgInSecondConstr {
-    if (((slice.remainingBits >= 1) && (slice.preloadUint(1) == 0b0))) {
-        slice.loadUint(1);
-        return {
-            kind: 'ParamNamedArgInSecondConstr_a',
-            n: arg0,
-        }
-
-    }
-    if (((slice.remainingBits >= 1) && (slice.preloadUint(1) == 0b1))) {
-        slice.loadUint(1);
-        return {
-            kind: 'ParamNamedArgInSecondConstr_b',
-            n: (arg0 - 1),
-        }
-
-    }
-    throw new Error('Expected one of "ParamNamedArgInSecondConstr_a", "ParamNamedArgInSecondConstr_b" in loading "ParamNamedArgInSecondConstr", but data does not satisfy any constructor');
-}
-
-export function storeParamNamedArgInSecondConstr(paramNamedArgInSecondConstr: ParamNamedArgInSecondConstr): (builder: Builder) => void {
-    if ((paramNamedArgInSecondConstr.kind == 'ParamNamedArgInSecondConstr_a')) {
-        return ((builder: Builder) => {
-            builder.storeUint(0b0, 1);
-        })
-
-    }
-    if ((paramNamedArgInSecondConstr.kind == 'ParamNamedArgInSecondConstr_b')) {
-        return ((builder: Builder) => {
-            builder.storeUint(0b1, 1);
-        })
-
-    }
-    throw new Error('Expected one of "ParamNamedArgInSecondConstr_a", "ParamNamedArgInSecondConstr_b" in loading "ParamNamedArgInSecondConstr", but data does not satisfy any constructor');
-}
-
-// a$_ msg:^(Maybe Any) = RefCombinatorAny;
-
-export function loadRefCombinatorAny(slice: Slice): RefCombinatorAny {
-    let slice1 = slice.loadRef().beginParse();
-    let msg: Maybe<Slice> = loadMaybe<Slice>(slice1, ((slice: Slice) => {
-        return slice
-
-    }));
-    return {
-        kind: 'RefCombinatorAny',
-        msg: msg,
-    }
-
-}
-
-export function storeRefCombinatorAny(refCombinatorAny: RefCombinatorAny): (builder: Builder) => void {
-    return ((builder: Builder) => {
-        let cell1 = beginCell();
-        storeMaybe<Slice>(refCombinatorAny.msg, ((arg: Slice) => {
-            return ((builder: Builder) => {
-                builder.storeSlice(arg);
-            })
-
-        }))(cell1);
-        builder.storeRef(cell1);
-    })
-
-}
-
-// a$_ n:# { 5 + n = 7 } = EqualityExpression;
-
-export function loadEqualityExpression(slice: Slice): EqualityExpression {
-    let n: number = slice.loadUint(32);
-    if ((!((5 + n) == 7))) {
-        throw new Error('Condition ((5 + n) == 7) is not satisfied while loading "EqualityExpression" for type "EqualityExpression"');
-    }
-    return {
-        kind: 'EqualityExpression',
-        n: n,
-    }
-
-}
-
-export function storeEqualityExpression(equalityExpression: EqualityExpression): (builder: Builder) => void {
-    return ((builder: Builder) => {
-        builder.storeUint(equalityExpression.n, 32);
-        if ((!((5 + equalityExpression.n) == 7))) {
-            throw new Error('Condition ((5 + equalityExpression.n) == 7) is not satisfied while loading "EqualityExpression" for type "EqualityExpression"');
-        }
-    })
-
-}
-
-// a$_ x:(## 1) y:x?^Simple = ConditionalRef;
-
-export function loadConditionalRef(slice: Slice): ConditionalRef {
-    let x: number = slice.loadUint(1);
-    let y: Simple | undefined = (x ? ((slice: Slice) => {
-        let slice1 = slice.loadRef().beginParse();
-        return loadSimple(slice1)
-
-    })(slice) : undefined);
-    return {
-        kind: 'ConditionalRef',
-        x: x,
-        y: y,
-    }
-
-}
-
-export function storeConditionalRef(conditionalRef: ConditionalRef): (builder: Builder) => void {
-    return ((builder: Builder) => {
-        builder.storeUint(conditionalRef.x, 1);
-        if ((conditionalRef.y != undefined)) {
-            let cell1 = beginCell();
-            storeSimple(conditionalRef.y)(cell1);
-            builder.storeRef(cell1);
-
-        }
-    })
-
-}
-
-// block_info#9bc7a987 seq_no:# { prev_seq_no:# } { ~prev_seq_no + 1 = seq_no } = LoadFromNegationOutsideExpr;
-
-export function loadLoadFromNegationOutsideExpr(slice: Slice): LoadFromNegationOutsideExpr {
-    if (((slice.remainingBits >= 32) && (slice.preloadUint(32) == 0x9bc7a987))) {
-        slice.loadUint(32);
-        let seq_no: number = slice.loadUint(32);
-        return {
-            kind: 'LoadFromNegationOutsideExpr',
-            prev_seq_no: (seq_no - 1),
-            seq_no: seq_no,
-        }
-
-    }
-    throw new Error('Expected one of "LoadFromNegationOutsideExpr" in loading "LoadFromNegationOutsideExpr", but data does not satisfy any constructor');
-}
-
-export function storeLoadFromNegationOutsideExpr(loadFromNegationOutsideExpr: LoadFromNegationOutsideExpr): (builder: Builder) => void {
-    return ((builder: Builder) => {
-        builder.storeUint(0x9bc7a987, 32);
-        builder.storeUint(loadFromNegationOutsideExpr.seq_no, 32);
-    })
-
-}
-
-// bit$_ (## 1) anon0:# = AnonymousData;
-
-export function loadAnonymousData(slice: Slice): AnonymousData {
-    let anon0: number = slice.loadUint(1);
-    let anon0_0: number = slice.loadUint(32);
-    return {
-        kind: 'AnonymousData',
-        anon0: anon0,
-        anon0_0: anon0_0,
-    }
-
-}
-
-export function storeAnonymousData(anonymousData: AnonymousData): (builder: Builder) => void {
-    return ((builder: Builder) => {
-        builder.storeUint(anonymousData.anon0, 1);
-        builder.storeUint(anonymousData.anon0_0, 32);
-    })
-
-}
-
-// vm_stk_int#0201_ value:int257 = FalseAnonField;
-
-export function loadFalseAnonField(slice: Slice): FalseAnonField {
-    if (((slice.remainingBits >= 16) && (slice.preloadUint(16) == 0x0201))) {
-        slice.loadUint(16);
-        let value: bigint = slice.loadIntBig(257);
-        return {
-            kind: 'FalseAnonField',
-            value: value,
-        }
-
-    }
-    throw new Error('Expected one of "FalseAnonField" in loading "FalseAnonField", but data does not satisfy any constructor');
-}
-
-export function storeFalseAnonField(falseAnonField: FalseAnonField): (builder: Builder) => void {
-    return ((builder: Builder) => {
-        builder.storeUint(0x0201, 16);
-        builder.storeInt(falseAnonField.value, 257);
-    })
-
-}
-
-// a$0 a:Simple = ConstructorOrder;
-
-// _ Simple = ConstructorOrder;
-
-export function loadConstructorOrder(slice: Slice): ConstructorOrder {
-    if (((slice.remainingBits >= 1) && (slice.preloadUint(1) == 0b0))) {
-        slice.loadUint(1);
-        let a: Simple = loadSimple(slice);
-        return {
-            kind: 'ConstructorOrder_a',
-            a: a,
-        }
-
-    }
-    if (true) {
-        let anon0: Simple = loadSimple(slice);
-        return {
-            kind: 'ConstructorOrder__',
-            anon0: anon0,
-        }
-
-    }
-    throw new Error('Expected one of "ConstructorOrder_a", "ConstructorOrder__" in loading "ConstructorOrder", but data does not satisfy any constructor');
-}
-
-export function storeConstructorOrder(constructorOrder: ConstructorOrder): (builder: Builder) => void {
-    if ((constructorOrder.kind == 'ConstructorOrder_a')) {
-        return ((builder: Builder) => {
-            builder.storeUint(0b0, 1);
-            storeSimple(constructorOrder.a)(builder);
-        })
-
-    }
-    if ((constructorOrder.kind == 'ConstructorOrder__')) {
-        return ((builder: Builder) => {
-            storeSimple(constructorOrder.anon0)(builder);
-        })
-
-    }
-    throw new Error('Expected one of "ConstructorOrder_a", "ConstructorOrder__" in loading "ConstructorOrder", but data does not satisfy any constructor');
-}
-
-// a a:#  = CheckCrc32;
-
-// b b:# c:# = CheckCrc32;
-
-export function loadCheckCrc32(slice: Slice): CheckCrc32 {
-    if (((slice.remainingBits >= 32) && (slice.preloadUint(32) == 0x9d97e7a))) {
-        slice.loadUint(32);
-        let a: number = slice.loadUint(32);
-        return {
-            kind: 'CheckCrc32_a',
-            a: a,
-        }
-
-    }
-    if (((slice.remainingBits >= 32) && (slice.preloadUint(32) == 0x2842b3f0))) {
-        slice.loadUint(32);
-        let b: number = slice.loadUint(32);
-        let c: number = slice.loadUint(32);
-        return {
-            kind: 'CheckCrc32_b',
-            b: b,
-            c: c,
-        }
-
-    }
-    throw new Error('Expected one of "CheckCrc32_a", "CheckCrc32_b" in loading "CheckCrc32", but data does not satisfy any constructor');
-}
-
-export function storeCheckCrc32(checkCrc32: CheckCrc32): (builder: Builder) => void {
-    if ((checkCrc32.kind == 'CheckCrc32_a')) {
-        return ((builder: Builder) => {
-            builder.storeUint(0x9d97e7a, 32);
-            builder.storeUint(checkCrc32.a, 32);
-        })
-
-    }
-    if ((checkCrc32.kind == 'CheckCrc32_b')) {
-        return ((builder: Builder) => {
-            builder.storeUint(0x2842b3f0, 32);
-            builder.storeUint(checkCrc32.b, 32);
-            builder.storeUint(checkCrc32.c, 32);
-        })
-
-    }
-    throw new Error('Expected one of "CheckCrc32_a", "CheckCrc32_b" in loading "CheckCrc32", but data does not satisfy any constructor');
-}
-
-// a$_ const:# = CheckKeyword;
-
-export function loadCheckKeyword(slice: Slice): CheckKeyword {
-    let const0: number = slice.loadUint(32);
-    return {
-        kind: 'CheckKeyword',
-        const0: const0,
-    }
-
-}
-
-export function storeCheckKeyword(checkKeyword: CheckKeyword): (builder: Builder) => void {
-    return ((builder: Builder) => {
-        builder.storeUint(checkKeyword.const0, 32);
-    })
-
-}
-
-// a$_ {X:Type} t:# y:(Maybe ^X) = RefCombinatorInRefHelper X;
-
-export function loadRefCombinatorInRefHelper<X>(slice: Slice, loadX: (slice: Slice) => X): RefCombinatorInRefHelper<X> {
-    let t: number = slice.loadUint(32);
-    let y: Maybe<X> = loadMaybe<X>(slice, ((slice: Slice) => {
-        let slice1 = slice.loadRef().beginParse();
-        return loadX(slice1)
-
-    }));
-    return {
-        kind: 'RefCombinatorInRefHelper',
-        t: t,
-        y: y,
-    }
-
-}
-
-export function storeRefCombinatorInRefHelper<X>(refCombinatorInRefHelper: RefCombinatorInRefHelper<X>, storeX: (x: X) => (builder: Builder) => void): (builder: Builder) => void {
-    return ((builder: Builder) => {
-        builder.storeUint(refCombinatorInRefHelper.t, 32);
-        storeMaybe<X>(refCombinatorInRefHelper.y, ((arg: X) => {
-            return ((builder: Builder) => {
-                let cell1 = beginCell();
-                storeX(arg)(cell1);
-                builder.storeRef(cell1);
-
-            })
-
-        }))(builder);
-    })
-
-}
-
-// a$_ msg:^(RefCombinatorInRefHelper Any) = RefCombinatorInRef;
-
-export function loadRefCombinatorInRef(slice: Slice): RefCombinatorInRef {
-    let slice1 = slice.loadRef().beginParse();
-    let msg: RefCombinatorInRefHelper<Slice> = loadRefCombinatorInRefHelper<Slice>(slice1, ((slice: Slice) => {
-        return slice
-
-    }));
-    return {
-        kind: 'RefCombinatorInRef',
-        msg: msg,
-    }
-
-}
-
-export function storeRefCombinatorInRef(refCombinatorInRef: RefCombinatorInRef): (builder: Builder) => void {
-    return ((builder: Builder) => {
-        let cell1 = beginCell();
-        storeRefCombinatorInRefHelper<Slice>(refCombinatorInRef.msg, ((arg: Slice) => {
-            return ((builder: Builder) => {
-                builder.storeSlice(arg);
-            })
-
-        }))(cell1);
-        builder.storeRef(cell1);
-    })
-
-}
-
-// _ a:Bool = BoolUser;
-
-export function loadBoolUser(slice: Slice): BoolUser {
-    let a: boolean = slice.loadBoolean();
-    return {
-        kind: 'BoolUser',
-        a: a,
-    }
-
-}
-
-export function storeBoolUser(boolUser: BoolUser): (builder: Builder) => void {
-    return ((builder: Builder) => {
-        builder.storeBit(boolUser.a);
-    })
-
-}
-
-/*
-anycast_info$_ depth:(#<= 30) { depth >= 1 }
-   rewrite_pfx:(bits depth) = Anycast;
-*/
-
-export function loadAnycast(slice: Slice): Anycast {
-    let depth: number = slice.loadUint(bitLen(30));
-    let rewrite_pfx: BitString = slice.loadBits(depth);
-    if ((!(depth >= 1))) {
-        throw new Error('Condition (depth >= 1) is not satisfied while loading "Anycast" for type "Anycast"');
-    }
-    return {
-        kind: 'Anycast',
-        depth: depth,
-        rewrite_pfx: rewrite_pfx,
-    }
-
-}
-
-export function storeAnycast(anycast: Anycast): (builder: Builder) => void {
-    return ((builder: Builder) => {
-        builder.storeUint(anycast.depth, bitLen(30));
-        builder.storeBits(anycast.rewrite_pfx);
-        if ((!(anycast.depth >= 1))) {
-            throw new Error('Condition (anycast.depth >= 1) is not satisfied while loading "Anycast" for type "Anycast"');
-        }
-    })
-
-}
-
-// _ src:MsgAddressInt = AddressUser;
-
-export function loadAddressUser(slice: Slice): AddressUser {
-    let src: Address = slice.loadAddress();
-    return {
-        kind: 'AddressUser',
-        src: src,
-    }
-
-}
-
-export function storeAddressUser(addressUser: AddressUser): (builder: Builder) => void {
-    return ((builder: Builder) => {
-        builder.storeAddress(addressUser.src);
-    })
-
-}
-