eggplant 0.2.7

// Generated Eggplant Rust Code
// Source files referenced in comments below
use eggplant::{prelude::*, tx_rx_vt_pr};
use log::info;

// Source: ./code.lisp:3
// Datatype 'Expression' defined with variants:
//   - MNum: variant (defined at code.lisp:4)
//   - MVar: variant (defined at code.lisp:5)
//   - MAdd: variant (defined at code.lisp:6)
//   - MSub: variant (defined at code.lisp:7)
//   - MMul: variant (defined at code.lisp:8)
//   - MDiv: variant (defined at code.lisp:9)
//   - MMod: variant (defined at code.lisp:10)
//   - MMin: variant (defined at code.lisp:11)
//   - MMax: variant (defined at code.lisp:12)
//   - MAnd: variant (defined at code.lisp:13)
//   - MOr: variant (defined at code.lisp:14)
//   - MGte: variant (defined at code.lisp:15)
//   - MLt: variant (defined at code.lisp:16)
//   - MFloorTo: variant (defined at code.lisp:17)
//   - MReplace: variant (defined at code.lisp:18)
//   - MAccum: variant (defined at code.lisp:19)
#[eggplant::dsl]
enum Expression {
    MNum {
        num: i64,
    },
    MVar {
        name: String,
    },
    MAdd {
        l: Expression,
        r: Expression,
    },
    MSub {
        l: Expression,
        r: Expression,
    },
    MMul {
        l: Expression,
        r: Expression,
    },
    MDiv {
        l: Expression,
        r: Expression,
    },
    MMod {
        l: Expression,
        r: Expression,
    },
    MMin {
        l: Expression,
        r: Expression,
    },
    MMax {
        l: Expression,
        r: Expression,
    },
    MAnd {
        l: Expression,
        r: Expression,
    },
    MOr {
        l: Expression,
        r: Expression,
    },
    MGte {
        l: Expression,
        r: Expression,
    },
    MLt {
        l: Expression,
        r: Expression,
    },
    MFloorTo {
        l: Expression,
        r: Expression,
    },
    MReplace {
        l: Expression,
        r: Expression,
        rpl: Expression,
    },
    MAccum {
        name: String,
    },
}

#[eggplant::base_ty]
#[derive(Hash)]
enum UnOp {
    Exp2,
    Log2,
    Sqrt,
    Sin,
    Recip,
    Neg,
}

// Source: ./code.lisp:76
// Datatype 'BinOp' defined with variants:
//   - Add: variant (defined at code.lisp:77)
//   - Mul: variant (defined at code.lisp:78)
//   - Max: variant (defined at code.lisp:79)
#[eggplant::base_ty]
enum BinOp {
    Add,
    Mul,
    Max,
}

// Source: ./code.lisp:82
// Datatype 'IR' defined with variants:
//   - GMEM: variant (defined at code.lisp:83)
//   - LoopIn: variant (defined at code.lisp:84)
//   - LoopOut: variant (defined at code.lisp:85)
//   - Unary: variant (defined at code.lisp:86)
//   - Binary: variant (defined at code.lisp:87)
//   - SwapLoops: variant (defined at code.lisp:90)
//   - TileLoop: variant (defined at code.lisp:91)
//   - MergeLoops: variant (defined at code.lisp:92)
//   - TCMatmul: variant (defined at code.lisp:96)
//   - TiledMatmulInputA: variant (defined at code.lisp:97)
//   - TiledMatmulInputB: variant (defined at code.lisp:98)
#[eggplant::dsl]
enum IR {
    GMEM {
        name: String,
    },
    LoopIn {
        ir: IR,
        l: Expression,
        r: Expression,
    },
    LoopOut {
        ir: IR,
        l: Expression,
        r: Expression,
    },
    Unary {
        op: UnOp,
        ir: IR,
    },
    Binary {
        op: BinOp,
        l: IR,
        r: IR,
    },
    SwapLoops {
        ir: IR,
        level: i64,
    },
    TileLoop {
        ir: IR,
        level: i64,
    },
    MergeLoops {
        ir: IR,
        level: i64,
    },
    TCMatmul {
        inp_a: IR,
        inp_b: IR,
        a_k_stride: Expression,
        b_k_stride: Expression,
        a_inner_stride: Expression,
        b_inner_stride: Expression,
        c_inner_stride: Expression,
        num_k_loops: Expression,
    },
    TiledMatmulInputA {
        ir: IR,
        num: i64,
        expr: Expression,
    },
    TiledMatmulInputB {
        ir: IR,
        num: i64,
        expr: Expression,
    },
}

fn main() {
    env_logger::init();
    // Source: ./code.lisp:1
    let default_ruleset = MyTx::new_ruleset("default_ruleset");
    // Source: ./code.lisp:1
    tx_rx_vt_pr!(MyTx, MyPatRec);

    // Source: ./code.lisp:23
    // Pattern variables for rule matching
    // Variables: a, b, m_add_node1
    #[eggplant::pat_vars]
    struct AddCommuPat {
        a: Expression,
        b: Expression,
        m_add_node1: MAdd,
    }

    // Source: ./code.lisp:23
    // Rule: AddCommu
    // (rewrite (MAdd a b) (MAdd b a) :ruleset expr :name AddCommu)
    MyTx::add_rule(
        "AddCommu",
        default_ruleset,
        || {
            let a = Expression::query_leaf();
            let b = Expression::query_leaf();
            let m_add_node1 = MAdd::query(&a, &b);
            AddCommuPat::new(a, b, m_add_node1)
        },
        |ctx, pat| {
            let result = ctx.insert_m_add(pat.b, pat.a);
            ctx.union(pat.m_add_node1, result);
        },
    );

    // Source: ./code.lisp:24
    // Pattern variables for rule matching
    // Variables: a, b, m_mul_node1
    #[eggplant::pat_vars]
    struct MulCommuPat {
        a: Expression,
        b: Expression,
        m_mul_node1: MMul,
    }

    // Source: ./code.lisp:24
    // Rule: MulCommu
    // (rewrite (MMul a b) (MMul b a) :ruleset expr :name MulCommu)
    MyTx::add_rule(
        "MulCommu",
        default_ruleset,
        || {
            let a = Expression::query_leaf();
            let b = Expression::query_leaf();
            let m_mul_node1 = MMul::query(&a, &b);
            MulCommuPat::new(a, b, m_mul_node1)
        },
        |ctx, pat| {
            let result = ctx.insert_m_mul(pat.b, pat.a);
            ctx.union(pat.m_mul_node1, result);
        },
    );

    // Source: ./code.lisp:27
    // Pattern variables for rule matching
    // Variables: a, b, c, m_add_node2, m_add_node1
    #[eggplant::pat_vars]
    struct AddAssocPat {
        a: Expression,
        b: Expression,
        c: Expression,
        m_add_node2: MAdd,
        m_add_node1: MAdd,
    }

    // Source: ./code.lisp:27
    // Rule: AddAssoc
    // (rewrite (MAdd (MAdd a b) c) (MAdd a (MAdd b c)) :ruleset expr :name AddAssoc)
    MyTx::add_rule(
        "AddAssoc",
        default_ruleset,
        || {
            let a = Expression::query_leaf();
            let b = Expression::query_leaf();
            let m_add_node2 = MAdd::query(&a, &b);
            let c = Expression::query_leaf();
            let m_add_node1 = MAdd::query(&m_add_node2, &c);
            AddAssocPat::new(a, b, c, m_add_node2, m_add_node1)
        },
        |ctx, pat| {
            let result = ctx.insert_m_add(pat.a, ctx.insert_m_add(pat.b, pat.c));
            ctx.union(pat.m_add_node1, result);
        },
    );

    // Source: ./code.lisp:28
    // Pattern variables for rule matching
    // Variables: a, b, c, m_mul_node2, m_mul_node1
    #[eggplant::pat_vars]
    struct MulAssocPat {
        a: Expression,
        b: Expression,
        c: Expression,
        m_mul_node2: MMul,
        m_mul_node1: MMul,
    }

    // Source: ./code.lisp:28
    // Rule: MulAssoc
    // (rewrite (MMul (MMul a b) c) (MMul a (MMul b c)) :ruleset expr :name MulAssoc)
    MyTx::add_rule(
        "MulAssoc",
        default_ruleset,
        || {
            let a = Expression::query_leaf();
            let b = Expression::query_leaf();
            let m_mul_node2 = MMul::query(&a, &b);
            let c = Expression::query_leaf();
            let m_mul_node1 = MMul::query(&m_mul_node2, &c);
            MulAssocPat::new(a, b, c, m_mul_node2, m_mul_node1)
        },
        |ctx, pat| {
            let result = ctx.insert_m_mul(pat.a, ctx.insert_m_mul(pat.b, pat.c));
            ctx.union(pat.m_mul_node1, result);
        },
    );

    // Source: ./code.lisp:31
    // Pattern variables for rule matching
    // Variables: m_num_node2, m_num_node3, m_add_node1
    #[eggplant::pat_vars]
    struct AddFoldPat {
        m_num_node2: MNum,
        m_num_node3: MNum,
        m_add_node1: MAdd,
    }

    // Source: ./code.lisp:31
    // Rule: AddFold
    // (rewrite (MAdd (MNum a) (MNum b)) (MNum (+ a b)) :ruleset expr :name AddFold)
    MyTx::add_rule(
        "AddFold",
        default_ruleset,
        || {
            let m_num_node2 = MNum::query();
            let m_num_node3 = MNum::query();
            let m_add_node1 = MAdd::query(&m_num_node2, &m_num_node3);
            AddFoldPat::new(m_num_node2, m_num_node3, m_add_node1)
        },
        |ctx, pat| {
            let result = ctx.insert_m_num(
                (ctx.devalue(pat.m_num_node2.num) + ctx.devalue(pat.m_num_node3.num)),
            );
            ctx.union(pat.m_add_node1, result);
        },
    );

    // Source: ./code.lisp:32
    // Pattern variables for rule matching
    // Variables: m_num_node2, m_num_node3, m_sub_node1
    #[eggplant::pat_vars]
    struct SubFoldPat {
        m_num_node2: MNum,
        m_num_node3: MNum,
        m_sub_node1: MSub,
    }

    // Source: ./code.lisp:32
    // Rule: SubFold
    // (rewrite (MSub (MNum a) (MNum b)) (MNum (- a b)) :ruleset expr :name SubFold)
    MyTx::add_rule(
        "SubFold",
        default_ruleset,
        || {
            let m_num_node2 = MNum::query();
            let m_num_node3 = MNum::query();
            let m_sub_node1 = MSub::query(&m_num_node2, &m_num_node3);
            SubFoldPat::new(m_num_node2, m_num_node3, m_sub_node1)
        },
        |ctx, pat| {
            let result = ctx.insert_m_num(
                (ctx.devalue(pat.m_num_node2.num) - ctx.devalue(pat.m_num_node3.num)),
            );
            ctx.union(pat.m_sub_node1, result);
        },
    );

    // Source: ./code.lisp:33
    // Pattern variables for rule matching
    // Variables: m_num_node2, m_num_node3, m_mul_node1
    #[eggplant::pat_vars]
    struct MulFoldPat {
        m_num_node2: MNum,
        m_num_node3: MNum,
        m_mul_node1: MMul,
    }

    // Source: ./code.lisp:33
    // Rule: MulFold
    // (rewrite (MMul (MNum ?a) (MNum ?b)) (MNum (* ?a ?b)) :ruleset expr :name MulFold)
    MyTx::add_rule(
        "MulFold",
        default_ruleset,
        || {
            let m_num_node2 = MNum::query();
            let m_num_node3 = MNum::query();
            let m_mul_node1 = MMul::query(&m_num_node2, &m_num_node3);
            MulFoldPat::new(m_num_node2, m_num_node3, m_mul_node1)
        },
        |ctx, pat| {
            let result = ctx.insert_m_num(
                (ctx.devalue(pat.m_num_node2.num) * ctx.devalue(pat.m_num_node3.num)),
            );
            ctx.union(pat.m_mul_node1, result);
        },
    );

    // Source: ./code.lisp:35
    // Pattern variables for rule matching
    // Variables: m_num_node2, m_num_node3, m_max_node1
    #[eggplant::pat_vars]
    struct MaxFoldPat {
        m_num_node2: MNum,
        m_num_node3: MNum,
        m_max_node1: MMax,
    }

    // Source: ./code.lisp:35
    // Rule: MaxFold
    // (rewrite (MMax (MNum a) (MNum b)) (MNum (max a b)) :ruleset expr :name MaxFold)
    MyTx::add_rule(
        "MaxFold",
        default_ruleset,
        || {
            let m_num_node2 = MNum::query();
            let m_num_node3 = MNum::query();
            let m_max_node1 = MMax::query(&m_num_node2, &m_num_node3);
            MaxFoldPat::new(m_num_node2, m_num_node3, m_max_node1)
        },
        |ctx, pat| {
            let result = ctx.insert_m_num(std::cmp::max(
                ctx.devalue(pat.m_num_node2.num),
                ctx.devalue(pat.m_num_node3.num),
            ));
            ctx.union(pat.m_max_node1, result);
        },
    );

    // Source: ./code.lisp:36
    // Pattern variables for rule matching
    // Variables: m_num_node2, m_num_node3, m_min_node1
    #[eggplant::pat_vars]
    struct MinFoldPat {
        m_num_node2: MNum,
        m_num_node3: MNum,
        m_min_node1: MMin,
    }

    // Source: ./code.lisp:36
    // Rule: MinFold
    // (rewrite (MMin (MNum a) (MNum b)) (MNum (min a b)) :ruleset expr :name MinFold)
    MyTx::add_rule(
        "MinFold",
        default_ruleset,
        || {
            let m_num_node2 = MNum::query();
            let m_num_node3 = MNum::query();
            let m_min_node1 = MMin::query(&m_num_node2, &m_num_node3);
            MinFoldPat::new(m_num_node2, m_num_node3, m_min_node1)
        },
        |ctx, pat| {
            let result = ctx.insert_m_num(std::cmp::min(
                ctx.devalue(pat.m_num_node2.num),
                ctx.devalue(pat.m_num_node3.num),
            ));
            ctx.union(pat.m_min_node1, result);
        },
    );

    // Source: ./code.lisp:37
    // Pattern variables for rule matching
    // Variables: m_num_node3, m_num_node2, m_and_node1
    #[eggplant::pat_vars]
    struct AndFoldPat {
        m_num_node3: MNum,
        m_num_node2: MNum,
        m_and_node1: MAnd,
    }

    // Source: ./code.lisp:37
    // Rule: AndFold
    // (rewrite (MAnd (MNum a) (MNum b)) (MNum (& a b)) :ruleset expr :name AndFold)
    MyTx::add_rule(
        "AndFold",
        default_ruleset,
        || {
            let m_num_node2 = MNum::query();
            let m_num_node3 = MNum::query();
            let m_and_node1 = MAnd::query(&m_num_node2, &m_num_node3);
            AndFoldPat::new(m_num_node3, m_num_node2, m_and_node1)
        },
        |ctx, pat| {
            let result = ctx.insert_m_num(std::ops::BitAnd::bitand(
                ctx.devalue(pat.m_num_node2.num),
                ctx.devalue(pat.m_num_node3.num),
            ));
            ctx.union(pat.m_and_node1, result);
        },
    );

    // Source: ./code.lisp:40
    // Pattern variables for rule matching
    // Variables: a, m_add_node1
    #[eggplant::pat_vars]
    struct AddZeroPat {
        a: Expression,
        m_add_node1: MAdd,
    }

    // Source: ./code.lisp:40
    // Rule: AddZero
    // (rewrite (MAdd a (MNum 0)) a :ruleset expr :name AddZero)
    MyTx::add_rule(
        "AddZero",
        default_ruleset,
        || {
            let a = Expression::query_leaf();
            let m_num_node2 = MNum::query();
            let m_add_node1 = MAdd::query(&a, &m_num_node2);
            AddZeroPat::new(a, m_add_node1)
        },
        |ctx, pat| {
            let result = pat.a;
            ctx.union(pat.m_add_node1, result);
        },
    );

    // Source: ./code.lisp:41
    // Pattern variables for rule matching
    // Variables: a, m_mul_node1
    #[eggplant::pat_vars]
    struct MulOnePat {
        a: Expression,
        m_mul_node1: MMul,
    }

    // Source: ./code.lisp:41
    // Rule: MulOne
    // (rewrite (MMul a (MNum 1)) a :ruleset expr :name MulOne)
    MyTx::add_rule(
        "MulOne",
        default_ruleset,
        || {
            let a = Expression::query_leaf();
            let m_num_node2 = MNum::query();
            let m_mul_node1 = MMul::query(&a, &m_num_node2);
            MulOnePat::new(a, m_mul_node1)
        },
        |ctx, pat| {
            let result = pat.a;
            ctx.union(pat.m_mul_node1, result);
        },
    );

    // Source: ./code.lisp:42
    // Pattern variables for rule matching
    // Variables: a, m_mul_node1
    #[eggplant::pat_vars]
    struct MulZeroPat {
        a: Expression,
        m_mul_node1: MMul,
    }

    // Source: ./code.lisp:42
    // Rule: MulZero
    // (rewrite (MMul a (MNum 0)) (MNum 0) :ruleset expr :name MulZero)
    MyTx::add_rule(
        "MulZero",
        default_ruleset,
        || {
            let a = Expression::query_leaf();
            let m_num_node2 = MNum::query();
            let m_mul_node1 = MMul::query(&a, &m_num_node2);
            MulZeroPat::new(a, m_mul_node1)
        },
        |ctx, pat| {
            let result = ctx.insert_m_num(0);
            ctx.union(pat.m_mul_node1, result);
        },
    );

    // Source: ./code.lisp:43
    // Pattern variables for rule matching
    // Variables: a, m_div_node1
    #[eggplant::pat_vars]
    struct DivOnePat {
        a: Expression,
        m_div_node1: MDiv,
    }

    // Source: ./code.lisp:43
    // Rule: DivOne
    // (rewrite (MDiv a (MNum 1)) a :ruleset expr :name DivOne)
    MyTx::add_rule(
        "DivOne",
        default_ruleset,
        || {
            let a = Expression::query_leaf();
            let m_div_node1 = MDiv::query(&a, &MNum::query());
            DivOnePat::new(a, m_div_node1)
        },
        |ctx, pat| {
            let result = pat.a;
            ctx.union(pat.m_div_node1, result);
        },
    );

    // Source: ./code.lisp:44
    // Pattern variables for rule matching
    // Variables: _x, _y, m_mod_node1, m_mul_node2
    #[eggplant::pat_vars]
    struct ModMulToZeroPat {
        _x: Expression,
        _y: Expression,
        m_mod_node1: MMod,
        m_mul_node2: MMul,
    }

    // Source: ./code.lisp:44
    // Rule: ModMulToZero
    // (rewrite (MMod (MMul ?x ?y) ?y) (MNum 0) :ruleset expr :name ModMulToZero)
    MyTx::add_rule(
        "ModMulToZero",
        default_ruleset,
        || {
            let _x = Expression::query_leaf();
            let _y = Expression::query_leaf();
            let m_mul_node2 = MMul::query(&_x, &_y);
            let m_mod_node1 = MMod::query(&m_mul_node2, &_y);
            ModMulToZeroPat::new(_x, _y, m_mod_node1, m_mul_node2)
        },
        |ctx, pat| {
            let result = ctx.insert_m_num(0);
            ctx.union(pat.m_mod_node1, result);
        },
    );

    // Source: ./code.lisp:45
    // Pattern variables for rule matching
    // Variables: _x, m_num_node4, m_num_node3, m_mod_node2, m_mod_node1, lit_0, node_4
    #[eggplant::pat_vars]
    struct ModMod1Pat {
        _x: Expression,
        m_num_node4: MNum,
        m_num_node3: MNum,
        m_mod_node2: MMod,
        m_mod_node1: MMod,
    }

    // Source: ./code.lisp:45
    // Rule: ModMod1
    // (rewrite (MMod (MMod ?x (MNum ?y)) (MNum ?z)) (MMod ?x (MNum ?y)) :when ((>= ?z ?y) (= 0 (% ?y ?z))) :ruleset expr :name ModMod1)
    MyTx::add_rule(
        "ModMod1",
        default_ruleset,
        || {
            let _x = Expression::query_leaf();
            let m_num_node3 = MNum::query();
            let m_mod_node2 = MMod::query(&_x, &m_num_node3);
            let m_num_node4 = MNum::query();
            let m_mod_node1 = MMod::query(&m_mod_node2, &m_num_node4);
            let cond_z_y = { m_num_node4.handle_num().ge(&m_num_node3.handle_num()) };
            ModMod1Pat::new(_x, m_num_node4, m_num_node3, m_mod_node2, m_mod_node1).assert(cond_z_y)
        },
        |ctx, pat| {
            if ctx.devalue(pat.m_num_node3.num) % ctx.devalue(pat.m_num_node4.num) != 0 {
                return;
            }
            let result =
                ctx.insert_m_mod(pat._x, ctx.insert_m_num(ctx.devalue(pat.m_num_node3.num)));
            ctx.union(pat.m_mod_node1, result);
        },
    );

    // Source: ./code.lisp:46
    // Pattern variables for rule matching
    // Variables: _x, m_mod_node2, m_num_node3, m_num_node4, m_mod_node1, lit_0, node_4
    #[eggplant::pat_vars]
    struct ModMod2Pat {
        _x: Expression,
        m_mod_node2: MMod,
        m_num_node3: MNum,
        m_num_node4: MNum,
        m_mod_node1: MMod,
    }

    // Source: ./code.lisp:46
    // Rule: ModMod2
    // (rewrite (MMod (MMod ?x (MNum ?y)) (MNum ?z)) (MMod ?x (MNum ?z)) :when ((>= ?y ?z) (= 0 (% ?z ?y))) :ruleset expr :name ModMod2)
    MyTx::add_rule(
        "ModMod2",
        default_ruleset,
        || {
            let _x = Expression::query_leaf();
            let m_num_node3 = MNum::query();
            let m_mod_node2 = MMod::query(&_x, &m_num_node3);
            let m_num_node4 = MNum::query();
            let m_mod_node1 = MMod::query(&m_mod_node2, &m_num_node4);
            ModMod2Pat::new(_x, m_mod_node2, m_num_node3, m_num_node4, m_mod_node1)
        },
        |ctx, pat| {
            let y = ctx.devalue(pat.m_num_node3.num);
            let z = ctx.devalue(pat.m_num_node4.num);
            if (y >= z) && z % y == 0 {
                let result =
                    ctx.insert_m_mod(pat._x, ctx.insert_m_num(ctx.devalue(pat.m_num_node4.num)));
                ctx.union(pat.m_mod_node1, result);
            }
        },
    );

    // Source: ./code.lisp:49
    // Pattern variables for rule matching
    // Variables: _x, _y, _z, m_replace_node1
    #[eggplant::pat_vars]
    struct ReplacePat {
        _x: Expression,
        _y: Expression,
        _z: Expression,
        m_replace_node1: MReplace,
    }

    // Source: ./code.lisp:49
    // Rule: Replace
    // (rewrite (MReplace ?x ?y ?z) ?z :when ((= ?x ?y)) :ruleset expr :name Replace)
    MyTx::add_rule(
        "Replace",
        default_ruleset,
        || {
            let _x = Expression::query_leaf();
            let _y = Expression::query_leaf();
            let _z = Expression::query_leaf();
            let m_replace_node1 = MReplace::query(&_x, &_y, &_z);
            let cond__x__y = { _x.handle().eq(&_y.handle()) };
            ReplacePat::new(_x, _y, _z, m_replace_node1).assert(cond__x__y)
        },
        |ctx, pat| {
            let result = pat._z;
            ctx.union(pat.m_replace_node1, result);
        },
    );

    // Source: ./code.lisp:50
    // Pattern variables for rule matching
    // Variables: _a, _b, _x, _y, m_add_node2, m_replace_node1
    #[eggplant::pat_vars]
    struct ReplaceRecurAddPat {
        _a: Expression,
        _b: Expression,
        _x: Expression,
        _y: Expression,
        m_add_node2: MAdd,
        m_replace_node1: MReplace,
    }

    // Source: ./code.lisp:50
    // Rule: ReplaceRecurAdd
    // (rewrite (MReplace (MAdd ?a ?b) ?x ?y) (MAdd (MReplace ?a ?x ?y) (MReplace ?b ?x ?y)) :ruleset expr :name ReplaceRecurAdd)
    MyTx::add_rule(
        "ReplaceRecurAdd",
        default_ruleset,
        || {
            let _a = Expression::query_leaf();
            let _b = Expression::query_leaf();
            let m_add_node2 = MAdd::query(&_a, &_b);
            let _x = Expression::query_leaf();
            let _y = Expression::query_leaf();
            let m_replace_node1 = MReplace::query(&m_add_node2, &_x, &_y);
            ReplaceRecurAddPat::new(_a, _b, _x, _y, m_add_node2, m_replace_node1)
        },
        |ctx, pat| {
            let result = ctx.insert_m_add(
                ctx.insert_m_replace(pat._a, pat._x, pat._y),
                ctx.insert_m_replace(pat._b, pat._x, pat._y),
            );
            ctx.union(pat.m_replace_node1, result);
        },
    );

    // Source: ./code.lisp:51
    // Pattern variables for rule matching
    // Variables: _a, _b, _x, _y, m_replace_node1, m_sub_node2
    #[eggplant::pat_vars]
    struct ReplaceRecurSubPat {
        _a: Expression,
        _b: Expression,
        _x: Expression,
        _y: Expression,
        m_replace_node1: MReplace,
        m_sub_node2: MSub,
    }

    // Source: ./code.lisp:51
    // Rule: ReplaceRecurSub
    // (rewrite (MReplace (MSub ?a ?b) ?x ?y) (MSub (MReplace ?a ?x ?y) (MReplace ?b ?x ?y)) :ruleset expr :name ReplaceRecurSub)
    MyTx::add_rule(
        "ReplaceRecurSub",
        default_ruleset,
        || {
            let _a = Expression::query_leaf();
            let _b = Expression::query_leaf();
            let m_sub_node2 = MSub::query(&_a, &_b);
            let _x = Expression::query_leaf();
            let _y = Expression::query_leaf();
            let m_replace_node1 = MReplace::query(&m_sub_node2, &_x, &_y);
            ReplaceRecurSubPat::new(_a, _b, _x, _y, m_replace_node1, m_sub_node2)
        },
        |ctx, pat| {
            let result = ctx.insert_m_sub(
                ctx.insert_m_replace(pat._a, pat._x, pat._y),
                ctx.insert_m_replace(pat._b, pat._x, pat._y),
            );
            ctx.union(pat.m_replace_node1, result);
        },
    );

    // Source: ./code.lisp:52
    // Pattern variables for rule matching
    // Variables: _a, _b, _x, _y, m_mul_node2, m_replace_node1
    #[eggplant::pat_vars]
    struct ReplaceRecurMulPat {
        _a: Expression,
        _b: Expression,
        _x: Expression,
        _y: Expression,
        m_mul_node2: MMul,
        m_replace_node1: MReplace,
    }

    // Source: ./code.lisp:52
    // Rule: ReplaceRecurMul
    // (rewrite (MReplace (MMul ?a ?b) ?x ?y) (MMul (MReplace ?a ?x ?y) (MReplace ?b ?x ?y)) :ruleset expr :name ReplaceRecurMul)
    MyTx::add_rule(
        "ReplaceRecurMul",
        default_ruleset,
        || {
            let _a = Expression::query_leaf();
            let _b = Expression::query_leaf();
            let m_mul_node2 = MMul::query(&_a, &_b);
            let _x = Expression::query_leaf();
            let _y = Expression::query_leaf();
            let m_replace_node1 = MReplace::query(&m_mul_node2, &_x, &_y);
            ReplaceRecurMulPat::new(_a, _b, _x, _y, m_mul_node2, m_replace_node1)
        },
        |ctx, pat| {
            let result = ctx.insert_m_mul(
                ctx.insert_m_replace(pat._a, pat._x, pat._y),
                ctx.insert_m_replace(pat._b, pat._x, pat._y),
            );
            ctx.union(pat.m_replace_node1, result);
        },
    );

    // Source: ./code.lisp:53
    // Pattern variables for rule matching
    // Variables: _a, _b, _x, _y, m_replace_node1, m_div_node2
    #[eggplant::pat_vars]
    struct ReplaceRecurDivPat {
        _a: Expression,
        _b: Expression,
        _x: Expression,
        _y: Expression,
        m_replace_node1: MReplace,
        m_div_node2: MDiv,
    }

    // Source: ./code.lisp:53
    // Rule: ReplaceRecurDiv
    // (rewrite (MReplace (MDiv ?a ?b) ?x ?y) (MDiv (MReplace ?a ?x ?y) (MReplace ?b ?x ?y)) :ruleset expr :name ReplaceRecurDiv)
    MyTx::add_rule(
        "ReplaceRecurDiv",
        default_ruleset,
        || {
            let _a = Expression::query_leaf();
            let _b = Expression::query_leaf();
            let m_div_node2 = MDiv::query(&_a, &_b);
            let _x = Expression::query_leaf();
            let _y = Expression::query_leaf();
            let m_replace_node1 = MReplace::query(&m_div_node2, &_x, &_y);
            ReplaceRecurDivPat::new(_a, _b, _x, _y, m_replace_node1, m_div_node2)
        },
        |ctx, pat| {
            let result = ctx.insert_m_div(
                ctx.insert_m_replace(pat._a, pat._x, pat._y),
                ctx.insert_m_replace(pat._b, pat._x, pat._y),
            );
            ctx.union(pat.m_replace_node1, result);
        },
    );

    // Source: ./code.lisp:54
    // Pattern variables for rule matching
    // Variables: _a, _b, _x, _y, m_replace_node1, m_mod_node2
    #[eggplant::pat_vars]
    struct ReplaceRecurModPat {
        _a: Expression,
        _b: Expression,
        _x: Expression,
        _y: Expression,
        m_replace_node1: MReplace,
        m_mod_node2: MMod,
    }

    // Source: ./code.lisp:54
    // Rule: ReplaceRecurMod
    // (rewrite (MReplace (MMod ?a ?b) ?x ?y) (MMod (MReplace ?a ?x ?y) (MReplace ?b ?x ?y)) :ruleset expr :name ReplaceRecurMod)
    MyTx::add_rule(
        "ReplaceRecurMod",
        default_ruleset,
        || {
            let _a = Expression::query_leaf();
            let _b = Expression::query_leaf();
            let m_mod_node2 = MMod::query(&_a, &_b);
            let _x = Expression::query_leaf();
            let _y = Expression::query_leaf();
            let m_replace_node1 = MReplace::query(&m_mod_node2, &_x, &_y);
            ReplaceRecurModPat::new(_a, _b, _x, _y, m_replace_node1, m_mod_node2)
        },
        |ctx, pat| {
            let result = ctx.insert_m_mod(
                ctx.insert_m_replace(pat._a, pat._x, pat._y),
                ctx.insert_m_replace(pat._b, pat._x, pat._y),
            );
            ctx.union(pat.m_replace_node1, result);
        },
    );

    // Source: ./code.lisp:55
    // Pattern variables for rule matching
    // Variables: _a, _b, _x, _y, m_replace_node1, m_min_node2
    #[eggplant::pat_vars]
    struct ReplaceRecurMinPat {
        _a: Expression,
        _b: Expression,
        _x: Expression,
        _y: Expression,
        m_replace_node1: MReplace,
        m_min_node2: MMin,
    }

    // Source: ./code.lisp:55
    // Rule: ReplaceRecurMin
    // (rewrite (MReplace (MMin ?a ?b) ?x ?y) (MMin (MReplace ?a ?x ?y) (MReplace ?b ?x ?y)) :ruleset expr :name ReplaceRecurMin)
    MyTx::add_rule(
        "ReplaceRecurMin",
        default_ruleset,
        || {
            let _a = Expression::query_leaf();
            let _b = Expression::query_leaf();
            let m_min_node2 = MMin::query(&_a, &_b);
            let _x = Expression::query_leaf();
            let _y = Expression::query_leaf();
            let m_replace_node1 = MReplace::query(&m_min_node2, &_x, &_y);
            ReplaceRecurMinPat::new(_a, _b, _x, _y, m_replace_node1, m_min_node2)
        },
        |ctx, pat| {
            let result = ctx.insert_m_min(
                ctx.insert_m_replace(pat._a, pat._x, pat._y),
                ctx.insert_m_replace(pat._b, pat._x, pat._y),
            );
            ctx.union(pat.m_replace_node1, result);
        },
    );

    // Source: ./code.lisp:56
    // Pattern variables for rule matching
    // Variables: _a, _b, _x, _y, m_max_node2, m_replace_node1
    #[eggplant::pat_vars]
    struct ReplaceRecurMaxPat {
        _a: Expression,
        _b: Expression,
        _x: Expression,
        _y: Expression,
        m_max_node2: MMax,
        m_replace_node1: MReplace,
    }

    // Source: ./code.lisp:56
    // Rule: ReplaceRecurMax
    // (rewrite (MReplace (MMax ?a ?b) ?x ?y) (MMax (MReplace ?a ?x ?y) (MReplace ?b ?x ?y)) :ruleset expr :name ReplaceRecurMax)
    MyTx::add_rule(
        "ReplaceRecurMax",
        default_ruleset,
        || {
            let _a = Expression::query_leaf();
            let _b = Expression::query_leaf();
            let m_max_node2 = MMax::query(&_a, &_b);
            let _x = Expression::query_leaf();
            let _y = Expression::query_leaf();
            let m_replace_node1 = MReplace::query(&m_max_node2, &_x, &_y);
            ReplaceRecurMaxPat::new(_a, _b, _x, _y, m_max_node2, m_replace_node1)
        },
        |ctx, pat| {
            let result = ctx.insert_m_max(
                ctx.insert_m_replace(pat._a, pat._x, pat._y),
                ctx.insert_m_replace(pat._b, pat._x, pat._y),
            );
            ctx.union(pat.m_replace_node1, result);
        },
    );

    // Source: ./code.lisp:57
    // Pattern variables for rule matching
    // Variables: _a, _b, _x, _y, m_replace_node1, m_floor_to_node2
    #[eggplant::pat_vars]
    struct ReplaceRecurFloorPat {
        _a: Expression,
        _b: Expression,
        _x: Expression,
        _y: Expression,
        m_replace_node1: MReplace,
        m_floor_to_node2: MFloorTo,
    }

    // Source: ./code.lisp:57
    // Rule: ReplaceRecurFloor
    // (rewrite (MReplace (MFloorTo ?a ?b) ?x ?y) (MFloorTo (MReplace ?a ?x ?y) (MReplace ?b ?x ?y)) :ruleset expr :name ReplaceRecurFloor)
    MyTx::add_rule(
        "ReplaceRecurFloor",
        default_ruleset,
        || {
            let _a = Expression::query_leaf();
            let _b = Expression::query_leaf();
            let m_floor_to_node2 = MFloorTo::query(&_a, &_b);
            let _x = Expression::query_leaf();
            let _y = Expression::query_leaf();
            let m_replace_node1 = MReplace::query(&m_floor_to_node2, &_x, &_y);
            ReplaceRecurFloorPat::new(_a, _b, _x, _y, m_replace_node1, m_floor_to_node2)
        },
        |ctx, pat| {
            let result = ctx.insert_m_floor_to(
                ctx.insert_m_replace(pat._a, pat._x, pat._y),
                ctx.insert_m_replace(pat._b, pat._x, pat._y),
            );
            ctx.union(pat.m_replace_node1, result);
        },
    );

    // Source: ./code.lisp:59
    // Pattern variables for rule matching
    // Variables: _x, _y, m_replace_node1, m_num_node2
    #[eggplant::pat_vars]
    struct ReplaceRecurNumPat {
        _x: Expression,
        _y: Expression,
        m_replace_node1: MReplace,
        m_num_node2: MNum,
    }

    // Source: ./code.lisp:59
    // Rule: ReplaceRecurNum
    // (rewrite (MReplace (MNum ?n) ?x ?y) (MNum ?n) :ruleset expr :name ReplaceRecurNum)
    MyTx::add_rule(
        "ReplaceRecurNum",
        default_ruleset,
        || {
            let m_num_node2 = MNum::query();
            let _x = Expression::query_leaf();
            let _y = Expression::query_leaf();
            let m_replace_node1 = MReplace::query(&m_num_node2, &_x, &_y);
            ReplaceRecurNumPat::new(_x, _y, m_replace_node1, m_num_node2)
        },
        |ctx, pat| {
            let result = ctx.insert_m_num(ctx.devalue(pat.m_num_node2.num));
            ctx.union(pat.m_replace_node1, result);
        },
    );

    // Source: ./code.lisp:60
    // Pattern variables for rule matching
    // Variables: _x, _y, m_replace_node1, m_accum_node2
    #[eggplant::pat_vars]
    struct ReplaceRecurAccumPat {
        _x: Expression,
        _y: Expression,
        m_replace_node1: MReplace,
        m_accum_node2: MAccum,
    }

    // Source: ./code.lisp:60
    // Rule: ReplaceRecurAccum
    // (rewrite (MReplace (MAccum ?acc) ?x ?y) (MAccum ?acc) :ruleset expr :name ReplaceRecurAccum)
    MyTx::add_rule(
        "ReplaceRecurAccum",
        default_ruleset,
        || {
            let m_accum_node2 = MAccum::query();
            let _x = Expression::query_leaf();
            let _y = Expression::query_leaf();
            let m_replace_node1 = MReplace::query(&m_accum_node2, &_x, &_y);
            ReplaceRecurAccumPat::new(_x, _y, m_replace_node1, m_accum_node2)
        },
        |ctx, pat| {
            let result = ctx.insert_m_accum(ctx.devalue(pat.m_accum_node2.name));
            ctx.union(pat.m_replace_node1, result);
        },
    );

    // Source: ./code.lisp:63
    // Pattern variables for rule matching
    // Variables: _y, m_replace_node1, m_var_node3, m_var_node2
    #[eggplant::pat_vars]
    struct ReplaceRecurVarPat {
        _y: Expression,
        m_replace_node1: MReplace,
        m_var_node3: MVar,
        m_var_node2: MVar,
    }

    // Source: ./code.lisp:63
    // Rule: ReplaceRecurVar
    // (rewrite (MReplace (MVar ?v) (MVar ?x) ?y) (MVar ?v) :when ((!= ?v ?x)) :ruleset expr :name ReplaceRecurVar)
    MyTx::add_rule(
        "ReplaceRecurVar",
        default_ruleset,
        || {
            let m_var_node2 = MVar::query();
            let m_var_node3 = MVar::query();
            let _y = Expression::query_leaf();
            let m_replace_node1 = MReplace::query(&m_var_node2, &m_var_node3, &_y);
            let cond_v_x = { m_var_node2.handle_name().ne(&m_var_node3.handle_name()) };
            ReplaceRecurVarPat::new(_y, m_replace_node1, m_var_node3, m_var_node2).assert(cond_v_x)
        },
        |ctx, pat| {
            let result = ctx.insert_m_var(ctx.devalue(pat.m_var_node2.name));
            ctx.union(pat.m_replace_node1, result);
        },
    );

    // Source: ./code.lisp:1
    MyTx::run_ruleset(default_ruleset, RunConfig::Sat);
    info!("Eggplant program executed successfully!");
}