fn calc(b: i64, c: i64) -> i64 {
    return ((c * 3 + c) * (c - b * 7));
}
fn main() -> i64 {
    let r = calc(5, 3);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    let c = ((c * 3 + c) * (c - b * 7));
    return c;
}
fn main() -> i64 {
    let r = calc(5, 3);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    let t = (c * 3 + c);
    t = t * (c - b * 7);
    return t;
}
fn main() -> i64 {
    let r = calc(5, 3);
    println(r);
    return 0;
}

fn calc(c: i64, b: i64) -> i64 {
    return ((c * 3 + c) * (c - b * 7));
}
fn main() -> i64 {
    let r = calc(5, 3);
    println(r);
    return 0;
}


fn calc(a: i64, b: i64, c: i64) -> i64 {
    let c = 6 * c;
    return c;
}
fn main() -> i64 {
    let r = calc(6, 9, 3);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64, c: i64) -> i64 {
    return 6 * c;
}
fn main() -> i64 {
    let r = calc(6, 9, 3);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64, c: i64) -> i64 {
    let c = 6 * c;
    return c;
}
fn main( -> i64 {
    let r = calc(6, 9, 3);
    println(r);
    return 0;
}


fn calc(d: i64, e: i64) -> i64 {
    let t = e;
    t = t + d * d;
    return t;
}
fn main() -> i64 {
    let r = calc(2, 0);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    let c = (e + d * d);
    return c;
}
fn main() -> i64 {
    let r = calc(2, 0);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    return (e + d * d);
}
fn main() -> i64 {
    let r = calc(2, 0);
    println(r);
    return 0;
}

fn calc(e: i64, d: i64) -> i64 {
    let t = e;
    t = t + d * d;
    return t;
}
fn main() -> i64 {
    let r = calc(2, 0);
    println(r);
    return 0;
}


fn calc(a: i64, e: i64) -> i64 {
    return e + 0;
}
fn main() -> i64 {
    let r = calc(6, 12);
    println(r);
    return 0;
}

fn calc(a: i64, e: i64) -> i64 {
    let c = e + 0;
    return c;
}
fn main() -> i64 {
    let r = calc(6, 12);
    println(r);
    return 0;
}

fn calc(a: i64, e: i64) -> i64 {
    return e + 0;
}
fn main() -> i64 {
    let r = calc(6, 12;
    println(r);
    return 0;
}


fn calc(a: i64, e: i64) -> i64 {
    return e + 1;
}
fn main() -> i64 {
    let r = calc(7, 6);
    println(r);
    return 0;
}

fn calc(a: i64, e: i64) -> i64 {
    let c = e + 1;
    return c;
}
fn main() -> i64 {
    let r = calc(7, 6);
    println(r);
    return 0;
}

fn calc(a: i64, e: i64) -> i64 {
    return e - 1;
}
fn main() -> i64 {
    let r = calc(7, 6);
    println(r);
    return 0;
}


fn calc(d: i64, e: i64) -> i64 {
    let t = (e * 2 + e);
    t = t * (e * d - e);
    return t;
}
fn main() -> i64 {
    let r = calc(6, 8);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    return ((e * 2 + e) * (e * d - e));
}
fn main() -> i64 {
    let r = calc(6, 8);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    let c = ((e * 2 + e) * (e * d - e));
    return c;
}
fn main() -> i64 {
    let r = calc(6, 8);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    let t = (e * 3 + e);
    t = t * (e * d - e);
    return t;
}
fn main() -> i64 {
    let r = calc(6, 8);
    println(r);
    return 0;
}


fn calc(c: i64) -> i64 {
    let t = 0;
    t = t * c * c;
    return t;
}
fn main() -> i64 {
    let r = calc(9);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    let c = (0 * c * c);
    return c;
}
fn main() -> i64 {
    let r = calc(9);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    return (0 * c * c);
}
fn main() -> i64 {
    let r = calc(9);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    let t = 0;
    t = t * c * c;
    return t;
}
fn main() -> i64 {
    let r = calc(9);
    println(r;
    return 0;
}


fn calc(c: i64) -> i64 {
    let t = 8;
    t = t * c * c;
    return t;
}
fn main() -> i64 {
    let r = calc(6);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    return (8 * c * c);
}
fn main() -> i64 {
    let r = calc(6);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    let c = (8 * c * c);
    return c;
}
fn main() -> i64 {
    let r = calc(6);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    let t = 9;
    t = t * c * c;
    return t;
}
fn main() -> i64 {
    let r = calc(6);
    println(r);
    return 0;
}


fn calc(c: i64) -> i64 {
    let t = (c + 1 + c * 3);
    t = t + (c + 3 * 7);
    return t;
}
fn main() -> i64 {
    let r = calc(2);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    let c = ((c + 1 + c * 3) + (c + 3 * 7));
    return c;
}
fn main() -> i64 {
    let r = calc(2);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    return ((c + 1 + c * 3) + (c + 3 * 7));
}
fn main() -> i64 {
    let r = calc(2);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    let t = (c - 1 + c * 3);
    t = t + (c + 3 * 7);
    return t;
}
fn main() -> i64 {
    let r = calc(2);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64) -> i64 {
    return (2 - 7 * c);
}
fn main() -> i64 {
    let r = calc(12, 7);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    let c = (2 - 7 * c);
    return c;
}
fn main() -> i64 {
    let r = calc(12, 7);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    let t = 2;
    t = t - 7 * c;
    return t;
}
fn main() -> i64 {
    let r = calc(12, 7);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64 -> i64 {
    return (2 - 7 * c);
}
fn main() -> i64 {
    let r = calc(12, 7);
    println(r);
    return 0;
}


fn calc(c: i64, d: i64, e: i64) -> i64 {
    return (c * 9);
}
fn main() -> i64 {
    let r = calc(6, 1, 5);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64, e: i64) -> i64 {
    let c = (c * 9);
    return c;
}
fn main() -> i64 {
    let r = calc(6, 1, 5);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64, e: i64) -> i64 {
    let t = c;
    t = t * 9;
    return t;
}
fn main() -> i64 {
    let r = calc(6, 1, 5);
    println(r);
    return 0;
}

fn calc(d: i64, c: i64, e: i64) -> i64 {
    return (c * 9);
}
fn main() -> i64 {
    let r = calc(6, 1, 5);
    println(r);
    return 0;
}


fn calc(c: i64, d: i64, e: i64) -> i64 {
    return (c * 2);
}
fn main() -> i64 {
    let r = calc(5, 9, 0);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64, e: i64) -> i64 {
    let t = c;
    t = t * 2;
    return t;
}
fn main() -> i64 {
    let r = calc(5, 9, 0);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64, e: i64) -> i64 {
    let c = (c * 2);
    return c;
}
fn main() -> i64 {
    let r = calc(5, 9, 0);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64, e: i64) -> i64 {
    return (c * 2);
}
fn main() -> i64 {
    let r = calc(5, 9, 0);
    println(r;
    return 0;
}


fn calc(e: i64) -> i64 {
    let t = e;
    t = t + e * e;
    return t;
}
fn main() -> i64 {
    let r = calc(6);
    println(r);
    return 0;
}

fn calc(e: i64) -> i64 {
    let c = (e + e * e);
    return c;
}
fn main() -> i64 {
    let r = calc(6);
    println(r);
    return 0;
}

fn calc(e: i64) -> i64 {
    return (e + e * e);
}
fn main() -> i64 {
    let r = calc(6);
    println(r);
    return 0;
}

fn calc(e: i64) -> i64 {
    let t = e;
    t = t + e + e;
    return t;
}
fn main() -> i64 {
    let r = calc(6);
    println(r);
    return 0;
}


fn calc(a: i64) -> i64 {
    let c = (a * (a * a - a * 6));
    return c;
}
fn main() -> i64 {
    let r = calc(10);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    return (a * (a * a - a * 6));
}
fn main() -> i64 {
    let r = calc(10);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    let t = a;
    t = t * (a * a - a * 6);
    return t;
}
fn main() -> i64 {
    let r = calc(10);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    let c = (a * (a * a - a * 6);
    return c;
}
fn main() -> i64 {
    let r = calc(10);
    println(r);
    return 0;
}


fn calc(a: i64, b: i64) -> i64 {
    let c = (b + 0 + 2);
    return c;
}
fn main() -> i64 {
    let r = calc(6, 2);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64) -> i64 {
    let t = b;
    t = t + 0 + 2;
    return t;
}
fn main() -> i64 {
    let r = calc(6, 2);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64) -> i64 {
    return (b + 0 + 2);
}
fn main() -> i64 {
    let r = calc(6, 2);
    println(r);
    return 0;
}


fn calc(b: i64, e: i64) -> i64 {
    let c = (5 * b);
    return c;
}
fn main() -> i64 {
    let r = calc(0, 6);
    println(r);
    return 0;
}

fn calc(b: i64, e: i64) -> i64 {
    return (5 * b);
}
fn main() -> i64 {
    let r = calc(0, 6);
    println(r);
    return 0;
}

fn calc(b: i64, e: i64) -> i64 {
    let t = 5;
    t = t * b;
    return t;
}
fn main() -> i64 {
    let r = calc(0, 6);
    println(r);
    return 0;
}

fn calc(b: i64, e: i64) -> i64 {
    let c = (5 + b);
    return c;
}
fn main() -> i64 {
    let r = calc(0, 6);
    println(r);
    return 0;
}


fn calc(b: i64, e: i64) -> i64 {
    let c = (7 * b);
    return c;
}
fn main() -> i64 {
    let r = calc(11, 4);
    println(r);
    return 0;
}

fn calc(b: i64, e: i64) -> i64 {
    return (7 * b);
}
fn main() -> i64 {
    let r = calc(11, 4);
    println(r);
    return 0;
}

fn calc(b: i64, e: i64) -> i64 {
    let t = 7;
    t = t * b;
    return t;
}
fn main() -> i64 {
    let r = calc(11, 4);
    println(r);
    return 0;
}

fn calc(e: i64, b: i64) -> i64 {
    let c = (7 * b);
    return c;
}
fn main() -> i64 {
    let r = calc(11, 4);
    println(r);
    return 0;
}


fn calc(b: i64, e: i64) -> i64 {
    let c = (7 * b);
    return c;
}
fn main() -> i64 {
    let r = calc(6, 1);
    println(r);
    return 0;
}

fn calc(b: i64, e: i64) -> i64 {
    return (7 * b);
}
fn main() -> i64 {
    let r = calc(6, 1);
    println(r);
    return 0;
}

fn calc(b: i64, e: i64) -> i64 {
    let t = 7;
    t = t * b;
    return t;
}
fn main() -> i64 {
    let r = calc(6, 1);
    println(r);
    return 0;
}

fn calc(e: i64, b: i64) -> i64 {
    let c = (7 * b);
    return c;
}
fn main() -> i64 {
    let r = calc(6, 1);
    println(r);
    return 0;
}


fn calc(b: i64) -> i64 {
    return ((5 + b * 5 * b) + 5);
}
fn main() -> i64 {
    let r = calc(12);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    let t = (5 + b * 5 * b);
    t = t + 5;
    return t;
}
fn main() -> i64 {
    let r = calc(12);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    let c = ((5 + b * 5 * b) + 5);
    return c;
}
fn main() -> i64 {
    let r = calc(12);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    return ((5 + b * 6 * b) + 5);
}
fn main() -> i64 {
    let r = calc(12);
    println(r);
    return 0;
}


fn calc(c: i64, d: i64) -> i64 {
    return ((c + d * c * c) + (c - 7 + d + c));
}
fn main() -> i64 {
    let r = calc(4, 4);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    let c = ((c + d * c * c) + (c - 7 + d + c));
    return c;
}
fn main() -> i64 {
    let r = calc(4, 4);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    let t = (c + d * c * c);
    t = t + (c - 7 + d + c);
    return t;
}
fn main() -> i64 {
    let r = calc(4, 4);
    println(r);
    return 0;
}


fn calc(b: i64, d: i64, e: i64) -> i64 {
    let t = 2;
    t = t + d * 7;
    return t;
}
fn main() -> i64 {
    let r = calc(3, 6, 8);
    println(r);
    return 0;
}

fn calc(b: i64, d: i64, e: i64) -> i64 {
    let c = (2 + d * 7);
    return c;
}
fn main() -> i64 {
    let r = calc(3, 6, 8);
    println(r);
    return 0;
}

fn calc(b: i64, d: i64, e: i64) -> i64 {
    return (2 + d * 7);
}
fn main() -> i64 {
    let r = calc(3, 6, 8);
    println(r);
    return 0;
}

fn calc(b: i64, d: i64, e: i64) -> i64 {
    let t = 2;
    t = t + d + 7;
    return t;
}
fn main() -> i64 {
    let r = calc(3, 6, 8);
    println(r);
    return 0;
}


fn calc(a: i64, d: i64, e: i64) -> i64 {
    let t = (7 * a * e * d);
    t = t - (a + e - 7 + e);
    return t;
}
fn main() -> i64 {
    let r = calc(10, 9, 3);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64) -> i64 {
    let c = c - c;
    return c;
}
fn main() -> i64 {
    let r = calc(4, 1);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    return c - c;
}
fn main() -> i64 {
    let r = calc(4, 1);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    let c = c + c;
    return c;
}
fn main() -> i64 {
    let r = calc(4, 1);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64) -> i64 {
    let c = c - c;
    return c;
}
fn main() -> i64 {
    let r = calc(12, 9);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    return c - c;
}
fn main() -> i64 {
    let r = calc(12, 9);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    let c = c + c;
    return c;
}
fn main() -> i64 {
    let r = calc(12, 9);
    println(r);
    return 0;
}


fn calc(b: i64) -> i64 {
    return (b + 5 * b - b);
}
fn main() -> i64 {
    let r = calc(9);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    let c = (b + 5 * b - b);
    return c;
}
fn main() -> i64 {
    let r = calc(9);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    let t = b;
    t = t + 5 * b - b;
    return t;
}
fn main() -> i64 {
    let r = calc(9);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    return (b - 5 * b - b);
}
fn main() -> i64 {
    let r = calc(9);
    println(r);
    return 0;
}


fn calc(a: i64, c: i64, e: i64) -> i64 {
    return (e * a * c);
}
fn main() -> i64 {
    let r = calc(2, 3, 3);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64, e: i64) -> i64 {
    let c = (e * a * c);
    return c;
}
fn main() -> i64 {
    let r = calc(2, 3, 3);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64, e: i64) -> i64 {
    let t = e;
    t = t * a * c;
    return t;
}
fn main() -> i64 {
    let r = calc(2, 3, 3);
    println(r);
    return 0;
}


fn calc(d: i64, e: i64) -> i64 {
    let c = (9 * e * e);
    return c;
}
fn main() -> i64 {
    let r = calc(6, 8);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    return (9 * e * e);
}
fn main() -> i64 {
    let r = calc(6, 8);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    let t = 9;
    t = t * e * e;
    return t;
}
fn main() -> i64 {
    let r = calc(6, 8);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64 -> i64 {
    let c = (9 * e * e);
    return c;
}
fn main() -> i64 {
    let r = calc(6, 8);
    println(r);
    return 0;
}


fn calc(d: i64) -> i64 {
    return (d * d * 2);
}
fn main() -> i64 {
    let r = calc(9);
    println(r);
    return 0;
}

fn calc(d: i64) -> i64 {
    let t = d;
    t = t * d * 2;
    return t;
}
fn main() -> i64 {
    let r = calc(9);
    println(r);
    return 0;
}

fn calc(d: i64) -> i64 {
    let c = (d * d * 2);
    return c;
}
fn main() -> i64 {
    let r = calc(9);
    println(r);
    return 0;
}

fn calc(d: i64) -> i64 {
    return (d * d * 2);
}
fn main( -> i64 {
    let r = calc(9);
    println(r);
    return 0;
}


fn calc(a: i64, e: i64) -> i64 {
    return (a * 1 * e + 9);
}
fn main() -> i64 {
    let r = calc(3, 7);
    println(r);
    return 0;
}

fn calc(a: i64, e: i64) -> i64 {
    let t = a;
    t = t * 1 * e + 9;
    return t;
}
fn main() -> i64 {
    let r = calc(3, 7);
    println(r);
    return 0;
}

fn calc(a: i64, e: i64) -> i64 {
    let c = (a * 1 * e + 9);
    return c;
}
fn main() -> i64 {
    let r = calc(3, 7);
    println(r);
    return 0;
}


fn calc(b: i64, e: i64) -> i64 {
    let t = (e * b * e + b);
    t = t - (2 * b + 0 * 8);
    return t;
}
fn main() -> i64 {
    let r = calc(12, 4);
    println(r);
    return 0;
}

fn calc(b: i64, e: i64) -> i64 {
    let c = ((e * b * e + b) - (2 * b + 0 * 8));
    return c;
}
fn main() -> i64 {
    let r = calc(12, 4);
    println(r);
    return 0;
}


fn calc(d: i64) -> i64 {
    let c = (2 * 6 * 8 + 6);
    return c;
}
fn main() -> i64 {
    let r = calc(0);
    println(r);
    return 0;
}

fn calc(d: i64) -> i64 {
    return (2 * 6 * 8 + 6);
}
fn main() -> i64 {
    let r = calc(0);
    println(r);
    return 0;
}

fn calc(d: i64) -> i64 {
    let t = 2;
    t = t * 6 * 8 + 6;
    return t;
}
fn main() -> i64 {
    let r = calc(0);
    println(r);
    return 0;
}

fn calc(d: i64) -> i64 {
    let c = (2 * 6 * 8 - 6);
    return c;
}
fn main() -> i64 {
    let r = calc(0);
    println(r);
    return 0;
}


fn calc(c: i64) -> i64 {
    return (c * c + c);
}
fn main() -> i64 {
    let r = calc(8);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    let c = (c * c + c);
    return c;
}
fn main() -> i64 {
    let r = calc(8);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    let t = c;
    t = t * c + c;
    return t;
}
fn main() -> i64 {
    let r = calc(8);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    return (c * c + c);
}
fn main() -> i64 {
    let r = calc(8);
    println(r;
    return 0;
}


fn calc(b: i64) -> i64 {
    let t = (1 + b * b * b);
    t = t + (b - b * 0);
    return t;
}
fn main() -> i64 {
    let r = calc(12);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    return ((1 + b * b * b) + (b - b * 0));
}
fn main() -> i64 {
    let r = calc(12);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    let c = ((1 + b * b * b) + (b - b * 0));
    return c;
}
fn main() -> i64 {
    let r = calc(12);
    println(r);
    return 0;
}


fn calc(a: i64, c: i64) -> i64 {
    return ((2 * c + c) - (c * 0 + a));
}
fn main() -> i64 {
    let r = calc(12, 1);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64) -> i64 {
    let t = (2 * c + c);
    t = t - (c * 0 + a);
    return t;
}
fn main() -> i64 {
    let r = calc(12, 1);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64) -> i64 {
    let c = ((2 * c + c) - (c * 0 + a));
    return c;
}
fn main() -> i64 {
    let r = calc(12, 1);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64) -> i64 {
    return ((2 * c + c) - (c * 0 + a));
}
fn main( -> i64 {
    let r = calc(12, 1);
    println(r);
    return 0;
}


fn calc(c: i64) -> i64 {
    let c = (c + 3 * 5 * c);
    return c;
}
fn main() -> i64 {
    let r = calc(8);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    let t = c;
    t = t + 3 * 5 * c;
    return t;
}
fn main() -> i64 {
    let r = calc(8);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    return (c + 3 * 5 * c);
}
fn main() -> i64 {
    let r = calc(8);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    let c = (c + 3 * 5 * c);
    return c;
}
fn main() -> i64 {
    let r = calc(8);
    println(r);
    return 1;
}


fn calc(b: i64) -> i64 {
    return (b * b * b);
}
fn main() -> i64 {
    let r = calc(0);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    let c = (b * b * b);
    return c;
}
fn main() -> i64 {
    let r = calc(0);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    let t = b;
    t = t * b * b;
    return t;
}
fn main() -> i64 {
    let r = calc(0);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    return (b * b * b);
}
fn main() -> i64 {
    let r = calc(0);
    println(r;
    return 0;
}


fn calc(b: i64) -> i64 {
    return (b * b * b);
}
fn main() -> i64 {
    let r = calc(12);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    let t = b;
    t = t * b * b;
    return t;
}
fn main() -> i64 {
    let r = calc(12);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    let c = (b * b * b);
    return c;
}
fn main() -> i64 {
    let r = calc(12);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    return (b + b * b);
}
fn main() -> i64 {
    let r = calc(12);
    println(r);
    return 0;
}


fn calc(b: i64) -> i64 {
    return (b * b * b);
}
fn main() -> i64 {
    let r = calc(7);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    let t = b;
    t = t * b * b;
    return t;
}
fn main() -> i64 {
    let r = calc(7);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    let c = (b * b * b);
    return c;
}
fn main() -> i64 {
    let r = calc(7);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    return (b + b * b);
}
fn main() -> i64 {
    let r = calc(7);
    println(r);
    return 0;
}


fn calc(d: i64, e: i64) -> i64 {
    let c = ((d - 5 * e + d) * e);
    return c;
}
fn main() -> i64 {
    let r = calc(11, 11);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    let t = (d - 5 * e + d);
    t = t * e;
    return t;
}
fn main() -> i64 {
    let r = calc(11, 11);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    return ((d - 5 * e + d) * e);
}
fn main() -> i64 {
    let r = calc(11, 11);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    let c = ((d - 5 * e + d) * e);
    return c;
}
fn main() -> i64 {
    let r = calc(10, 11);
    println(r);
    return 0;
}


fn calc(a: i64, d: i64) -> i64 {
    let t = 8;
    t = t - d + 1 + 3;
    return t;
}
fn main() -> i64 {
    let r = calc(3, 6);
    println(r);
    return 0;
}

fn calc(a: i64, d: i64) -> i64 {
    let c = (8 - d + 1 + 3);
    return c;
}
fn main() -> i64 {
    let r = calc(3, 6);
    println(r);
    return 0;
}

fn calc(a: i64, d: i64) -> i64 {
    return (8 - d + 1 + 3);
}
fn main() -> i64 {
    let r = calc(3, 6);
    println(r);
    return 0;
}

fn calc(a: i64, d: i64 -> i64 {
    let t = 8;
    t = t - d + 1 + 3;
    return t;
}
fn main() -> i64 {
    let r = calc(3, 6);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64) -> i64 {
    return b * c;
}
fn main() -> i64 {
    let r = calc(1, 7);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    let c = b * c;
    return c;
}
fn main() -> i64 {
    let r = calc(1, 7);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    return b * c;
}
fn main() -> i64 {
    let r = calc(0, 7);
    println(r);
    return 0;
}


fn calc(b: i64) -> i64 {
    return ((b * b + b) + b);
}
fn main() -> i64 {
    let r = calc(9);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    let t = (b * b + b);
    t = t + b;
    return t;
}
fn main() -> i64 {
    let r = calc(9);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    let c = ((b * b + b) + b);
    return c;
}
fn main() -> i64 {
    let r = calc(9);
    println(r);
    return 0;
}


fn calc(c: i64) -> i64 {
    let t = c;
    t = t * (c + c * c);
    return t;
}
fn main() -> i64 {
    let r = calc(9);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    let c = (c * (c + c * c));
    return c;
}
fn main() -> i64 {
    let r = calc(9);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    return (c * (c + c * c));
}
fn main() -> i64 {
    let r = calc(9);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    let t = c;
    t = t * (c + c * c);
    return t;
}
fn main( -> i64 {
    let r = calc(9);
    println(r);
    return 0;
}


fn calc(b: i64) -> i64 {
    return ((b * b) + (b - 3));
}
fn main() -> i64 {
    let r = calc(6);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    let c = ((b * b) + (b - 3));
    return c;
}
fn main() -> i64 {
    let r = calc(6);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    let t = (b * b);
    t = t + (b - 3);
    return t;
}
fn main() -> i64 {
    let r = calc(6);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    return ((b + b) + (b - 3));
}
fn main() -> i64 {
    let r = calc(6);
    println(r);
    return 0;
}


fn calc(a: i64, c: i64, e: i64) -> i64 {
    return c + 5;
}
fn main() -> i64 {
    let r = calc(0, 6, 0);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64, e: i64) -> i64 {
    let c = c + 5;
    return c;
}
fn main() -> i64 {
    let r = calc(0, 6, 0);
    println(r);
    return 0;
}

fn calc(c: i64, a: i64, e: i64) -> i64 {
    return c + 5;
}
fn main() -> i64 {
    let r = calc(0, 6, 0);
    println(r);
    return 0;
}


fn calc(d: i64, e: i64) -> i64 {
    let t = (d + d - 5 + e);
    t = t - (e * 7 - d * 4);
    return t;
}
fn main() -> i64 {
    let r = calc(5, 8);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    let c = ((d + d - 5 + e) - (e * 7 - d * 4));
    return c;
}
fn main() -> i64 {
    let r = calc(5, 8);
    println(r);
    return 0;
}

fn calc(e: i64, d: i64) -> i64 {
    let t = (d + d - 5 + e);
    t = t - (e * 7 - d * 4);
    return t;
}
fn main() -> i64 {
    let r = calc(5, 8);
    println(r);
    return 0;
}


fn calc(a: i64, c: i64, d: i64) -> i64 {
    let t = (1 + 9);
    t = t + (d * d * 8);
    return t;
}
fn main() -> i64 {
    let r = calc(4, 7, 0);
    println(r);
    return 0;
}


fn calc(a: i64, d: i64) -> i64 {
    let c = (3 + 7 + d);
    return c;
}
fn main() -> i64 {
    let r = calc(9, 3);
    println(r);
    return 0;
}

fn calc(a: i64, d: i64) -> i64 {
    return (3 + 7 + d);
}
fn main() -> i64 {
    let r = calc(9, 3);
    println(r);
    return 0;
}

fn calc(a: i64, d: i64) -> i64 {
    let t = 3;
    t = t + 7 + d;
    return t;
}
fn main() -> i64 {
    let r = calc(9, 3);
    println(r);
    return 0;
}


fn calc(c: i64, e: i64) -> i64 {
    let c = ((e * e + e - 5) + e);
    return c;
}
fn main() -> i64 {
    let r = calc(0, 12);
    println(r);
    return 0;
}

fn calc(c: i64, e: i64) -> i64 {
    let t = (e * e + e - 5);
    t = t + e;
    return t;
}
fn main() -> i64 {
    let r = calc(0, 12);
    println(r);
    return 0;
}

fn calc(c: i64, e: i64) -> i64 {
    return ((e * e + e - 5) + e);
}
fn main() -> i64 {
    let r = calc(0, 12);
    println(r);
    return 0;
}

fn calc(c: i64, e: i64) -> i64 {
    let c = ((e * e + e - 5) + e);
    return c;
}
fn main() -> i64 {
    let r = calc(0, 11);
    println(r);
    return 0;
}


fn calc(a: i64, c: i64, d: i64) -> i64 {
    let c = c;
    return c;
}
fn main() -> i64 {
    let r = calc(6, 6, 2);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64, d: i64) -> i64 {
    return c;
}
fn main() -> i64 {
    let r = calc(6, 6, 2);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64, d: i64) -> i64 {
    let c = c;
    return c;
}
fn main() -> i64 {
    let r = calc(6, 7, 2);
    println(r);
    return 0;
}


fn calc(a: i64, c: i64, d: i64) -> i64 {
    let c = c;
    return c;
}
fn main() -> i64 {
    let r = calc(0, 9, 10);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64, d: i64) -> i64 {
    return c;
}
fn main() -> i64 {
    let r = calc(0, 9, 10);
    println(r);
    return 0;
}


fn calc(a: i64, c: i64, d: i64) -> i64 {
    let c = c;
    return c;
}
fn main() -> i64 {
    let r = calc(12, 12, 11);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64, d: i64) -> i64 {
    return c;
}
fn main() -> i64 {
    let r = calc(12, 12, 11);
    println(r);
    return 0;
}


fn calc(a: i64, c: i64, d: i64) -> i64 {
    let c = c;
    return c;
}
fn main() -> i64 {
    let r = calc(8, 0, 4);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64, d: i64) -> i64 {
    return c;
}
fn main() -> i64 {
    let r = calc(8, 0, 4);
    println(r);
    return 0;
}


fn calc(a: i64, c: i64, d: i64) -> i64 {
    let c = c;
    return c;
}
fn main() -> i64 {
    let r = calc(9, 0, 6);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64, d: i64) -> i64 {
    return c;
}
fn main() -> i64 {
    let r = calc(9, 0, 6);
    println(r);
    return 0;
}

fn calc(a: i64, d: i64, c: i64) -> i64 {
    let c = c;
    return c;
}
fn main() -> i64 {
    let r = calc(9, 0, 6);
    println(r);
    return 0;
}


fn calc(a: i64, c: i64, d: i64) -> i64 {
    let c = c;
    return c;
}
fn main() -> i64 {
    let r = calc(8, 1, 6);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64, d: i64) -> i64 {
    return c;
}
fn main() -> i64 {
    let r = calc(8, 1, 6);
    println(r);
    return 0;
}


fn calc(a: i64, c: i64, d: i64) -> i64 {
    let c = c;
    return c;
}
fn main() -> i64 {
    let r = calc(11, 6, 1);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64, d: i64) -> i64 {
    return c;
}
fn main() -> i64 {
    let r = calc(11, 6, 1);
    println(r);
    return 0;
}

fn calc(a: i64, d: i64, c: i64) -> i64 {
    let c = c;
    return c;
}
fn main() -> i64 {
    let r = calc(11, 6, 1);
    println(r);
    return 0;
}


fn calc(a: i64, c: i64, d: i64) -> i64 {
    let c = c;
    return c;
}
fn main() -> i64 {
    let r = calc(7, 4, 11);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64, d: i64) -> i64 {
    return c;
}
fn main() -> i64 {
    let r = calc(7, 4, 11);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64, d: i64) -> i64 {
    let c = c;
    return c;
}
fn main() -> i64 {
    let r = calc(7, 4, 11);
    println(r;
    return 0;
}


fn calc(a: i64, c: i64, d: i64) -> i64 {
    let c = c;
    return c;
}
fn main() -> i64 {
    let r = calc(8, 0, 7);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64, d: i64) -> i64 {
    return c;
}
fn main() -> i64 {
    let r = calc(8, 0, 7);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64, d: i64) -> i64 {
    let c = c;
    return c;
}
fn main() -> i64 {
    let r = calc(8, 0, 7);
    println(r);
    return 1;
}


fn calc(a: i64, c: i64, d: i64) -> i64 {
    let c = c;
    return c;
}
fn main() -> i64 {
    let r = calc(6, 3, 2);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64, d: i64) -> i64 {
    return c;
}
fn main() -> i64 {
    let r = calc(6, 3, 2);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64, d: i64 -> i64 {
    let c = c;
    return c;
}
fn main() -> i64 {
    let r = calc(6, 3, 2);
    println(r);
    return 0;
}


fn calc(a: i64, c: i64, d: i64) -> i64 {
    let c = c;
    return c;
}
fn main() -> i64 {
    let r = calc(11, 10, 11);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64, d: i64) -> i64 {
    return c;
}
fn main() -> i64 {
    let r = calc(11, 10, 11);
    println(r);
    return 0;
}


fn calc(a: i64, b: i64) -> i64 {
    return (6 * a);
}
fn main() -> i64 {
    let r = calc(2, 10);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64) -> i64 {
    let c = (6 * a);
    return c;
}
fn main() -> i64 {
    let r = calc(2, 10);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64) -> i64 {
    let t = 6;
    t = t * a;
    return t;
}
fn main() -> i64 {
    let r = calc(2, 10);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64) -> i64 {
    return (6 * a);
}
fn main() -> i64 {
    let r = calc(2, 10);
    println(r);
    return 1;
}


fn calc(a: i64, b: i64) -> i64 {
    return (8 * a);
}
fn main() -> i64 {
    let r = calc(12, 3);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64) -> i64 {
    let c = (8 * a);
    return c;
}
fn main() -> i64 {
    let r = calc(12, 3);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64) -> i64 {
    let t = 8;
    t = t * a;
    return t;
}
fn main() -> i64 {
    let r = calc(12, 3);
    println(r);
    return 0;
}

fn calc(b: i64, a: i64) -> i64 {
    return (8 * a);
}
fn main() -> i64 {
    let r = calc(12, 3);
    println(r);
    return 0;
}


fn calc(a: i64, d: i64) -> i64 {
    let t = (d - a + 2 * 7);
    t = t * (7 * 7 + d * d);
    return t;
}
fn main() -> i64 {
    let r = calc(12, 3);
    println(r);
    return 0;
}


fn calc(b: i64) -> i64 {
    let c = ((b + b * b + b) + (5 * 1));
    return c;
}
fn main() -> i64 {
    let r = calc(11);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    let t = (b + b * b + b);
    t = t + (5 * 1);
    return t;
}
fn main() -> i64 {
    let r = calc(11);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    return ((b + b * b + b) + (5 * 1));
}
fn main() -> i64 {
    let r = calc(11);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    let c = ((b + b + b + b) + (5 * 1));
    return c;
}
fn main() -> i64 {
    let r = calc(11);
    println(r);
    return 0;
}


fn calc(a: i64, b: i64) -> i64 {
    let c = ((a + a * a) - (b * 9 + a));
    return c;
}
fn main() -> i64 {
    let r = calc(2, 2);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64) -> i64 {
    return ((a + a * a) - (b * 9 + a));
}
fn main() -> i64 {
    let r = calc(2, 2);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64) -> i64 {
    let t = (a + a * a);
    t = t - (b * 9 + a);
    return t;
}
fn main() -> i64 {
    let r = calc(2, 2);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64) -> i64 {
    let c = ((a + a * a) - (b * 9 + a));
    return c;
}
fn main() -> i64 {
    let r = calc(2, 2);
    println(r);
    return 1;
}


fn calc(a: i64, c: i64) -> i64 {
    return ((a * a + c * 5) * a);
}
fn main() -> i64 {
    let r = calc(10, 11);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64) -> i64 {
    let c = ((a * a + c * 5) * a);
    return c;
}
fn main() -> i64 {
    let r = calc(10, 11);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64) -> i64 {
    let t = (a * a + c * 5);
    t = t * a;
    return t;
}
fn main() -> i64 {
    let r = calc(10, 11);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64 -> i64 {
    return ((a * a + c * 5) * a);
}
fn main() -> i64 {
    let r = calc(10, 11);
    println(r);
    return 0;
}


fn calc(a: i64, b: i64, c: i64) -> i64 {
    return c;
}
fn main() -> i64 {
    let r = calc(4, 12, 4);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64, c: i64) -> i64 {
    let c = c;
    return c;
}
fn main() -> i64 {
    let r = calc(4, 12, 4);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64, b: i64) -> i64 {
    return c;
}
fn main() -> i64 {
    let r = calc(4, 12, 4);
    println(r);
    return 0;
}


fn calc(a: i64, b: i64, c: i64) -> i64 {
    return c;
}
fn main() -> i64 {
    let r = calc(6, 0, 1);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64, c: i64) -> i64 {
    let c = c;
    return c;
}
fn main() -> i64 {
    let r = calc(6, 0, 1);
    println(r);
    return 0;
}


fn calc(a: i64, b: i64, c: i64) -> i64 {
    return c;
}
fn main() -> i64 {
    let r = calc(2, 0, 7);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64, c: i64) -> i64 {
    let c = c;
    return c;
}
fn main() -> i64 {
    let r = calc(2, 0, 7);
    println(r);
    return 0;
}


fn calc(a: i64, b: i64, c: i64) -> i64 {
    return c;
}
fn main() -> i64 {
    let r = calc(0, 9, 3);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64, c: i64) -> i64 {
    let c = c;
    return c;
}
fn main() -> i64 {
    let r = calc(0, 9, 3);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64, c: i64) -> i64 {
    return c;
}
fn main( -> i64 {
    let r = calc(0, 9, 3);
    println(r);
    return 0;
}


fn calc(a: i64, b: i64, c: i64) -> i64 {
    return c;
}
fn main() -> i64 {
    let r = calc(4, 6, 4);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64, c: i64) -> i64 {
    let c = c;
    return c;
}
fn main() -> i64 {
    let r = calc(4, 6, 4);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64) -> i64 {
    let t = b;
    t = t * 9;
    return t;
}
fn main() -> i64 {
    let r = calc(6, 3);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    let c = (b * 9);
    return c;
}
fn main() -> i64 {
    let r = calc(6, 3);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    return (b * 9);
}
fn main() -> i64 {
    let r = calc(6, 3);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    let t = b;
    t = t * 9;
    return t;
}
fn main() -> i64 {
    let r = calc(7, 3);
    println(r);
    return 0;
}


fn calc(a: i64) -> i64 {
    let t = (a * a + 7);
    t = t - a;
    return t;
}
fn main() -> i64 {
    let r = calc(1);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    return ((a * a + 7) - a);
}
fn main() -> i64 {
    let r = calc(1);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    let c = ((a * a + 7) - a);
    return c;
}
fn main() -> i64 {
    let r = calc(1);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    let t = (a * a - 7);
    t = t - a;
    return t;
}
fn main() -> i64 {
    let r = calc(1);
    println(r);
    return 0;
}


fn calc(a: i64, b: i64, d: i64) -> i64 {
    let c = d * a;
    return c;
}
fn main() -> i64 {
    let r = calc(3, 4, 9);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64, d: i64) -> i64 {
    return d * a;
}
fn main() -> i64 {
    let r = calc(3, 4, 9);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64, d: i64) -> i64 {
    let c = d * a;
    return c;
}
fn main( -> i64 {
    let r = calc(3, 4, 9);
    println(r);
    return 0;
}


fn calc(c: i64, e: i64) -> i64 {
    let t = (c + c * c * e);
    t = t + (8 * e - e + c);
    return t;
}
fn main() -> i64 {
    let r = calc(6, 5);
    println(r);
    return 0;
}

fn calc(c: i64, e: i64) -> i64 {
    return ((c + c * c * e) + (8 * e - e + c));
}
fn main() -> i64 {
    let r = calc(6, 5);
    println(r);
    return 0;
}

fn calc(c: i64, e: i64) -> i64 {
    let c = ((c + c * c * e) + (8 * e - e + c));
    return c;
}
fn main() -> i64 {
    let r = calc(6, 5);
    println(r);
    return 0;
}

fn calc(c: i64, e: i64) -> i64 {
    let t = (c + c * c * e);
    t = t + (7 * e - e + c);
    return t;
}
fn main() -> i64 {
    let r = calc(6, 5);
    println(r);
    return 0;
}


fn calc(a: i64, c: i64) -> i64 {
    let t = a;
    t = t + a * 5;
    return t;
}
fn main() -> i64 {
    let r = calc(6, 0);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64) -> i64 {
    let c = (a + a * 5);
    return c;
}
fn main() -> i64 {
    let r = calc(6, 0);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64) -> i64 {
    return (a + a * 5);
}
fn main() -> i64 {
    let r = calc(6, 0);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64) -> i64 {
    let t = a;
    t = t + a * 5;
    return t;
}
fn main() -> i64 {
    let r = calc(6, 0;
    println(r);
    return 0;
}


fn calc(e: i64) -> i64 {
    let c = (e + e * e);
    return c;
}
fn main() -> i64 {
    let r = calc(12);
    println(r);
    return 0;
}

fn calc(e: i64) -> i64 {
    return (e + e * e);
}
fn main() -> i64 {
    let r = calc(12);
    println(r);
    return 0;
}

fn calc(e: i64) -> i64 {
    let t = e;
    t = t + e * e;
    return t;
}
fn main() -> i64 {
    let r = calc(12);
    println(r);
    return 0;
}

fn calc(e: i64) -> i64 {
    let c = (e + e * e);
    return c;
}
fn main() -> i64 {
    let r = calc(13);
    println(r);
    return 0;
}


fn calc(c: i64, d: i64) -> i64 {
    let c = (c * c * d * d);
    return c;
}
fn main() -> i64 {
    let r = calc(8, 10);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    return (c * c * d * d);
}
fn main() -> i64 {
    let r = calc(8, 10);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    let t = c;
    t = t * c * d * d;
    return t;
}
fn main() -> i64 {
    let r = calc(8, 10);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    let c = (c + c * d * d);
    return c;
}
fn main() -> i64 {
    let r = calc(8, 10);
    println(r);
    return 0;
}


fn calc(a: i64, d: i64, e: i64) -> i64 {
    return d;
}
fn main() -> i64 {
    let r = calc(5, 10, 11);
    println(r);
    return 0;
}

fn calc(a: i64, d: i64, e: i64) -> i64 {
    let c = d;
    return c;
}
fn main() -> i64 {
    let r = calc(5, 10, 11);
    println(r);
    return 0;
}

fn calc(a: i64, d: i64, e: i64 -> i64 {
    return d;
}
fn main() -> i64 {
    let r = calc(5, 10, 11);
    println(r);
    return 0;
}


fn calc(a: i64, d: i64, e: i64) -> i64 {
    return d;
}
fn main() -> i64 {
    let r = calc(4, 3, 10);
    println(r);
    return 0;
}

fn calc(a: i64, d: i64, e: i64) -> i64 {
    let c = d;
    return c;
}
fn main() -> i64 {
    let r = calc(4, 3, 10);
    println(r);
    return 0;
}


fn calc(a: i64, d: i64, e: i64) -> i64 {
    return d;
}
fn main() -> i64 {
    let r = calc(5, 3, 6);
    println(r);
    return 0;
}

fn calc(a: i64, d: i64, e: i64) -> i64 {
    let c = d;
    return c;
}
fn main() -> i64 {
    let r = calc(5, 3, 6);
    println(r);
    return 0;
}

fn calc(d: i64, a: i64, e: i64) -> i64 {
    return d;
}
fn main() -> i64 {
    let r = calc(5, 3, 6);
    println(r);
    return 0;
}


fn calc(a: i64, d: i64, e: i64) -> i64 {
    return d;
}
fn main() -> i64 {
    let r = calc(4, 0, 3);
    println(r);
    return 0;
}

fn calc(a: i64, d: i64, e: i64) -> i64 {
    let c = d;
    return c;
}
fn main() -> i64 {
    let r = calc(4, 0, 3);
    println(r);
    return 0;
}

fn calc(a: i64, d: i64, e: i64) -> i64 {
    return d;
}
fn main() -> i64 {
    let r = calc(4, 0, 3);
    println(r;
    return 0;
}


fn calc(a: i64, d: i64, e: i64) -> i64 {
    return d;
}
fn main() -> i64 {
    let r = calc(1, 8, 10);
    println(r);
    return 0;
}

fn calc(a: i64, d: i64, e: i64) -> i64 {
    let c = d;
    return c;
}
fn main() -> i64 {
    let r = calc(1, 8, 10);
    println(r);
    return 0;
}


fn calc(a: i64, d: i64, e: i64) -> i64 {
    return d;
}
fn main() -> i64 {
    let r = calc(4, 5, 2);
    println(r);
    return 0;
}

fn calc(a: i64, d: i64, e: i64) -> i64 {
    let c = d;
    return c;
}
fn main() -> i64 {
    let r = calc(4, 5, 2);
    println(r);
    return 0;
}

fn calc(a: i64, d: i64, e: i64 -> i64 {
    return d;
}
fn main() -> i64 {
    let r = calc(4, 5, 2);
    println(r);
    return 0;
}


fn calc(a: i64, d: i64, e: i64) -> i64 {
    return d;
}
fn main() -> i64 {
    let r = calc(4, 11, 11);
    println(r);
    return 0;
}

fn calc(a: i64, d: i64, e: i64) -> i64 {
    let c = d;
    return c;
}
fn main() -> i64 {
    let r = calc(4, 11, 11);
    println(r);
    return 0;
}

fn calc(d: i64, a: i64, e: i64) -> i64 {
    return d;
}
fn main() -> i64 {
    let r = calc(4, 11, 11);
    println(r);
    return 0;
}


fn calc(a: i64, d: i64, e: i64) -> i64 {
    return d;
}
fn main() -> i64 {
    let r = calc(5, 6, 9);
    println(r);
    return 0;
}

fn calc(a: i64, d: i64, e: i64) -> i64 {
    let c = d;
    return c;
}
fn main() -> i64 {
    let r = calc(5, 6, 9);
    println(r);
    return 0;
}


fn calc(a: i64, d: i64, e: i64) -> i64 {
    return d;
}
fn main() -> i64 {
    let r = calc(1, 1, 3);
    println(r);
    return 0;
}

fn calc(a: i64, d: i64, e: i64) -> i64 {
    let c = d;
    return c;
}
fn main() -> i64 {
    let r = calc(1, 1, 3);
    println(r);
    return 0;
}


fn calc(e: i64) -> i64 {
    let c = (0 + 9 + e + e);
    return c;
}
fn main() -> i64 {
    let r = calc(11);
    println(r);
    return 0;
}

fn calc(e: i64) -> i64 {
    return (0 + 9 + e + e);
}
fn main() -> i64 {
    let r = calc(11);
    println(r);
    return 0;
}

fn calc(e: i64) -> i64 {
    let t = 0;
    t = t + 9 + e + e;
    return t;
}
fn main() -> i64 {
    let r = calc(11);
    println(r);
    return 0;
}

fn calc(e: i64 -> i64 {
    let c = (0 + 9 + e + e);
    return c;
}
fn main() -> i64 {
    let r = calc(11);
    println(r);
    return 0;
}


fn calc(c: i64, e: i64) -> i64 {
    let t = (2 + 4 + 7 + 9);
    t = t + (c - 8 + c + e);
    return t;
}
fn main() -> i64 {
    let r = calc(4, 8);
    println(r);
    return 0;
}


fn calc(a: i64, b: i64) -> i64 {
    return (a * 6 * 4 + 5);
}
fn main() -> i64 {
    let r = calc(8, 6);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64) -> i64 {
    let t = a;
    t = t * 6 * 4 + 5;
    return t;
}
fn main() -> i64 {
    let r = calc(8, 6);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64) -> i64 {
    let c = (a * 6 * 4 + 5);
    return c;
}
fn main() -> i64 {
    let r = calc(8, 6);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64) -> i64 {
    return (a * 6 * 4 - 5);
}
fn main() -> i64 {
    let r = calc(8, 6);
    println(r);
    return 0;
}


fn calc(b: i64, d: i64) -> i64 {
    return 2 + d;
}
fn main() -> i64 {
    let r = calc(12, 0);
    println(r);
    return 0;
}

fn calc(b: i64, d: i64) -> i64 {
    let c = 2 + d;
    return c;
}
fn main() -> i64 {
    let r = calc(12, 0);
    println(r);
    return 0;
}

fn calc(b: i64, d: i64) -> i64 {
    return 1 + d;
}
fn main() -> i64 {
    let r = calc(12, 0);
    println(r);
    return 0;
}


fn calc(b: i64, d: i64) -> i64 {
    return 8 + d;
}
fn main() -> i64 {
    let r = calc(8, 11);
    println(r);
    return 0;
}

fn calc(b: i64, d: i64) -> i64 {
    let c = 8 + d;
    return c;
}
fn main() -> i64 {
    let r = calc(8, 11);
    println(r);
    return 0;
}

fn calc(b: i64, d: i64) -> i64 {
    return 7 + d;
}
fn main() -> i64 {
    let r = calc(8, 11);
    println(r);
    return 0;
}


fn calc(b: i64, d: i64) -> i64 {
    return 3 + d;
}
fn main() -> i64 {
    let r = calc(6, 7);
    println(r);
    return 0;
}

fn calc(b: i64, d: i64) -> i64 {
    let c = 3 + d;
    return c;
}
fn main() -> i64 {
    let r = calc(6, 7);
    println(r);
    return 0;
}

fn calc(b: i64, d: i64) -> i64 {
    return 3 - d;
}
fn main() -> i64 {
    let r = calc(6, 7);
    println(r);
    return 0;
}


fn calc(a: i64, d: i64) -> i64 {
    let c = ((4 - 3 + d * a) - (d + 1 + 0));
    return c;
}
fn main() -> i64 {
    let r = calc(2, 3);
    println(r);
    return 0;
}

fn calc(a: i64, d: i64) -> i64 {
    let t = (4 - 3 + d * a);
    t = t - (d + 1 + 0);
    return t;
}
fn main() -> i64 {
    let r = calc(2, 3);
    println(r);
    return 0;
}


fn calc(c: i64, d: i64) -> i64 {
    let t = c;
    t = t * c - d + c;
    return t;
}
fn main() -> i64 {
    let r = calc(4, 8);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    let c = (c * c - d + c);
    return c;
}
fn main() -> i64 {
    let r = calc(4, 8);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    return (c * c - d + c);
}
fn main() -> i64 {
    let r = calc(4, 8);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    let t = c;
    t = t * c - d + c;
    return t;
}
fn main() -> i64 {
    let r = calc(4, 7);
    println(r);
    return 0;
}


fn calc(b: i64) -> i64 {
    let c = (5 + 8 * b);
    return c;
}
fn main() -> i64 {
    let r = calc(5);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    let t = 5;
    t = t + 8 * b;
    return t;
}
fn main() -> i64 {
    let r = calc(5);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    return (5 + 8 * b);
}
fn main() -> i64 {
    let r = calc(5);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    let c = (5 + 8 * b;
    return c;
}
fn main() -> i64 {
    let r = calc(5);
    println(r);
    return 0;
}


fn calc(a: i64, b: i64, c: i64) -> i64 {
    return b + c;
}
fn main() -> i64 {
    let r = calc(2, 10, 0);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64, c: i64) -> i64 {
    let c = b + c;
    return c;
}
fn main() -> i64 {
    let r = calc(2, 10, 0);
    println(r);
    return 0;
}


fn calc(b: i64, d: i64, e: i64) -> i64 {
    return d + e;
}
fn main() -> i64 {
    let r = calc(3, 8, 5);
    println(r);
    return 0;
}

fn calc(b: i64, d: i64, e: i64) -> i64 {
    let c = d + e;
    return c;
}
fn main() -> i64 {
    let r = calc(3, 8, 5);
    println(r);
    return 0;
}

fn calc(b: i64, d: i64, e: i64) -> i64 {
    return d + e;
}
fn main() -> i64 {
    let r = calc(3, 9, 5);
    println(r);
    return 0;
}


fn calc(c: i64, e: i64) -> i64 {
    let t = c;
    t = t - c + e - 5;
    return t;
}
fn main() -> i64 {
    let r = calc(11, 12);
    println(r);
    return 0;
}

fn calc(c: i64, e: i64) -> i64 {
    let c = (c - c + e - 5);
    return c;
}
fn main() -> i64 {
    let r = calc(11, 12);
    println(r);
    return 0;
}

fn calc(c: i64, e: i64) -> i64 {
    return (c - c + e - 5);
}
fn main() -> i64 {
    let r = calc(11, 12);
    println(r);
    return 0;
}

fn calc(c: i64, e: i64) -> i64 {
    let t = c;
    t = t + c + e - 5;
    return t;
}
fn main() -> i64 {
    let r = calc(11, 12);
    println(r);
    return 0;
}


fn calc(c: i64) -> i64 {
    return ((c * c - 9 * c) * (5 + 1));
}
fn main() -> i64 {
    let r = calc(0);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    let t = (c * c - 9 * c);
    t = t * (5 + 1);
    return t;
}
fn main() -> i64 {
    let r = calc(0);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    let c = ((c * c - 9 * c) * (5 + 1));
    return c;
}
fn main() -> i64 {
    let r = calc(0);
    println(r);
    return 0;
}


fn calc(e: i64) -> i64 {
    return (5 - e - e * e);
}
fn main() -> i64 {
    let r = calc(10);
    println(r);
    return 0;
}

fn calc(e: i64) -> i64 {
    let t = 5;
    t = t - e - e * e;
    return t;
}
fn main() -> i64 {
    let r = calc(10);
    println(r);
    return 0;
}

fn calc(e: i64) -> i64 {
    let c = (5 - e - e * e);
    return c;
}
fn main() -> i64 {
    let r = calc(10);
    println(r);
    return 0;
}

fn calc(e: i64 -> i64 {
    return (5 - e - e * e);
}
fn main() -> i64 {
    let r = calc(10);
    println(r);
    return 0;
}


fn calc(b: i64) -> i64 {
    let c = (b + (b + 3 + 4));
    return c;
}
fn main() -> i64 {
    let r = calc(6);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    let t = b;
    t = t + (b + 3 + 4);
    return t;
}
fn main() -> i64 {
    let r = calc(6);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    return (b + (b + 3 + 4));
}
fn main() -> i64 {
    let r = calc(6);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    let c = (b + (b + 3 + 4));
    return c;
}
fn main() -> i64 {
    let r = calc(6);
    println(r;
    return 0;
}


fn calc(c: i64, e: i64) -> i64 {
    return (c + e + e - 5);
}
fn main() -> i64 {
    let r = calc(6, 11);
    println(r);
    return 0;
}

fn calc(c: i64, e: i64) -> i64 {
    let t = c;
    t = t + e + e - 5;
    return t;
}
fn main() -> i64 {
    let r = calc(6, 11);
    println(r);
    return 0;
}

fn calc(c: i64, e: i64) -> i64 {
    let c = (c + e + e - 5);
    return c;
}
fn main() -> i64 {
    let r = calc(6, 11);
    println(r);
    return 0;
}

fn calc(e: i64, c: i64) -> i64 {
    return (c + e + e - 5);
}
fn main() -> i64 {
    let r = calc(6, 11);
    println(r);
    return 0;
}


fn calc(a: i64, d: i64) -> i64 {
    let c = (a * 1);
    return c;
}
fn main() -> i64 {
    let r = calc(6, 11);
    println(r);
    return 0;
}

fn calc(a: i64, d: i64) -> i64 {
    return (a * 1);
}
fn main() -> i64 {
    let r = calc(6, 11);
    println(r);
    return 0;
}

fn calc(a: i64, d: i64) -> i64 {
    let t = a;
    t = t * 1;
    return t;
}
fn main() -> i64 {
    let r = calc(6, 11);
    println(r);
    return 0;
}

fn calc(a: i64, d: i64) -> i64 {
    let c = (a + 1);
    return c;
}
fn main() -> i64 {
    let r = calc(6, 11);
    println(r);
    return 0;
}


fn calc(e: i64) -> i64 {
    let t = e;
    t = t + e + e * 9;
    return t;
}
fn main() -> i64 {
    let r = calc(7);
    println(r);
    return 0;
}

fn calc(e: i64) -> i64 {
    let c = (e + e + e * 9);
    return c;
}
fn main() -> i64 {
    let r = calc(7);
    println(r);
    return 0;
}

fn calc(e: i64) -> i64 {
    return (e + e + e * 9);
}
fn main() -> i64 {
    let r = calc(7);
    println(r);
    return 0;
}

fn calc(e: i64) -> i64 {
    let t = e;
    t = t + e + e * 9;
    return t;
}
fn main( -> i64 {
    let r = calc(7);
    println(r);
    return 0;
}


fn calc(a: i64, e: i64) -> i64 {
    return (e * e + a);
}
fn main() -> i64 {
    let r = calc(2, 3);
    println(r);
    return 0;
}

fn calc(a: i64, e: i64) -> i64 {
    let t = e;
    t = t * e + a;
    return t;
}
fn main() -> i64 {
    let r = calc(2, 3);
    println(r);
    return 0;
}

fn calc(a: i64, e: i64) -> i64 {
    let c = (e * e + a);
    return c;
}
fn main() -> i64 {
    let r = calc(2, 3);
    println(r);
    return 0;
}

fn calc(a: i64, e: i64) -> i64 {
    return (e * e + a);
}
fn main() -> i64 {
    let r = calc(2, 3);
    println(r;
    return 0;
}


fn calc(e: i64) -> i64 {
    let c = (e - e * e);
    return c;
}
fn main() -> i64 {
    let r = calc(0);
    println(r);
    return 0;
}

fn calc(e: i64) -> i64 {
    let t = e;
    t = t - e * e;
    return t;
}
fn main() -> i64 {
    let r = calc(0);
    println(r);
    return 0;
}

fn calc(e: i64) -> i64 {
    return (e - e * e);
}
fn main() -> i64 {
    let r = calc(0);
    println(r);
    return 0;
}


fn calc(a: i64, d: i64, e: i64) -> i64 {
    return (8 + 2 + a * e);
}
fn main() -> i64 {
    let r = calc(9, 5, 2);
    println(r);
    return 0;
}

fn calc(a: i64, d: i64, e: i64) -> i64 {
    let c = (8 + 2 + a * e);
    return c;
}
fn main() -> i64 {
    let r = calc(9, 5, 2);
    println(r);
    return 0;
}

fn calc(a: i64, d: i64, e: i64) -> i64 {
    let t = 8;
    t = t + 2 + a * e;
    return t;
}
fn main() -> i64 {
    let r = calc(9, 5, 2);
    println(r);
    return 0;
}

fn calc(a: i64, d: i64, e: i64) -> i64 {
    return (8 + 2 + a * e;
}
fn main() -> i64 {
    let r = calc(9, 5, 2);
    println(r);
    return 0;
}


fn calc(b: i64, e: i64) -> i64 {
    return (3 + 3 * 0);
}
fn main() -> i64 {
    let r = calc(10, 10);
    println(r);
    return 0;
}

fn calc(b: i64, e: i64) -> i64 {
    let c = (3 + 3 * 0);
    return c;
}
fn main() -> i64 {
    let r = calc(10, 10);
    println(r);
    return 0;
}

fn calc(b: i64, e: i64) -> i64 {
    let t = 3;
    t = t + 3 * 0;
    return t;
}
fn main() -> i64 {
    let r = calc(10, 10);
    println(r);
    return 0;
}

fn calc(b: i64, e: i64 -> i64 {
    return (3 + 3 * 0);
}
fn main() -> i64 {
    let r = calc(10, 10);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64) -> i64 {
    let t = (b - b * b * b);
    t = t * b;
    return t;
}
fn main() -> i64 {
    let r = calc(4, 4);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    let c = ((b - b * b * b) * b);
    return c;
}
fn main() -> i64 {
    let r = calc(4, 4);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    return ((b - b * b * b) * b);
}
fn main() -> i64 {
    let r = calc(4, 4);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    let t = (b - b * b * b);
    t = t * b;
    return t;
}
fn main() -> i64 {
    let r = calc(4, 4);
    println(r);
    return 1;
}


fn calc(a: i64, b: i64, e: i64) -> i64 {
    return e - b;
}
fn main() -> i64 {
    let r = calc(9, 1, 3);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64, e: i64) -> i64 {
    let c = e - b;
    return c;
}
fn main() -> i64 {
    let r = calc(9, 1, 3);
    println(r);
    return 0;
}

fn calc(e: i64, b: i64, a: i64) -> i64 {
    return e - b;
}
fn main() -> i64 {
    let r = calc(9, 1, 3);
    println(r);
    return 0;
}


fn calc(a: i64, e: i64) -> i64 {
    let c = 2 + e;
    return c;
}
fn main() -> i64 {
    let r = calc(0, 4);
    println(r);
    return 0;
}

fn calc(a: i64, e: i64) -> i64 {
    return 2 + e;
}
fn main() -> i64 {
    let r = calc(0, 4);
    println(r);
    return 0;
}

fn calc(a: i64, e: i64) -> i64 {
    let c = 2 + e;
    return c;
}
fn main() -> i64 {
    let r = calc(0, 4;
    println(r);
    return 0;
}


fn calc(a: i64, e: i64) -> i64 {
    let c = 3 + e;
    return c;
}
fn main() -> i64 {
    let r = calc(5, 8);
    println(r);
    return 0;
}

fn calc(a: i64, e: i64) -> i64 {
    return 3 + e;
}
fn main() -> i64 {
    let r = calc(5, 8);
    println(r);
    return 0;
}

fn calc(e: i64, a: i64) -> i64 {
    let c = 3 + e;
    return c;
}
fn main() -> i64 {
    let r = calc(5, 8);
    println(r);
    return 0;
}


fn calc(a: i64, e: i64) -> i64 {
    return (e * a * 3 + a);
}
fn main() -> i64 {
    let r = calc(10, 10);
    println(r);
    return 0;
}

fn calc(a: i64, e: i64) -> i64 {
    let c = (e * a * 3 + a);
    return c;
}
fn main() -> i64 {
    let r = calc(10, 10);
    println(r);
    return 0;
}

fn calc(a: i64, e: i64) -> i64 {
    let t = e;
    t = t * a * 3 + a;
    return t;
}
fn main() -> i64 {
    let r = calc(10, 10);
    println(r);
    return 0;
}

fn calc(a: i64, e: i64) -> i64 {
    return (e * a * 3 - a);
}
fn main() -> i64 {
    let r = calc(10, 10);
    println(r);
    return 0;
}


fn calc(c: i64, e: i64) -> i64 {
    let c = (5 * 8 * e + c);
    return c;
}
fn main() -> i64 {
    let r = calc(8, 5);
    println(r);
    return 0;
}

fn calc(c: i64, e: i64) -> i64 {
    let t = 5;
    t = t * 8 * e + c;
    return t;
}
fn main() -> i64 {
    let r = calc(8, 5);
    println(r);
    return 0;
}

fn calc(c: i64, e: i64) -> i64 {
    return (5 * 8 * e + c);
}
fn main() -> i64 {
    let r = calc(8, 5);
    println(r);
    return 0;
}

fn calc(e: i64, c: i64) -> i64 {
    let c = (5 * 8 * e + c);
    return c;
}
fn main() -> i64 {
    let r = calc(8, 5);
    println(r);
    return 0;
}


fn calc(b: i64) -> i64 {
    return ((b - b + b - b) + 9);
}
fn main() -> i64 {
    let r = calc(10);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    let c = ((b - b + b - b) + 9);
    return c;
}
fn main() -> i64 {
    let r = calc(10);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    let t = (b - b + b - b);
    t = t + 9;
    return t;
}
fn main() -> i64 {
    let r = calc(10);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    return ((b + b + b - b) + 9);
}
fn main() -> i64 {
    let r = calc(10);
    println(r);
    return 0;
}


fn calc(b: i64) -> i64 {
    let c = b - b;
    return c;
}
fn main() -> i64 {
    let r = calc(7);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    return b - b;
}
fn main() -> i64 {
    let r = calc(7);
    println(r);
    return 0;
}

fn calc(b: i64 -> i64 {
    let c = b - b;
    return c;
}
fn main() -> i64 {
    let r = calc(7);
    println(r);
    return 0;
}


fn calc(b: i64) -> i64 {
    let c = b - b;
    return c;
}
fn main() -> i64 {
    let r = calc(12);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    return b - b;
}
fn main() -> i64 {
    let r = calc(12);
    println(r);
    return 0;
}

fn calc(b: i64 -> i64 {
    let c = b - b;
    return c;
}
fn main() -> i64 {
    let r = calc(12);
    println(r);
    return 0;
}


fn calc(b: i64) -> i64 {
    let c = b - b;
    return c;
}
fn main() -> i64 {
    let r = calc(2);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    return b - b;
}
fn main() -> i64 {
    let r = calc(2);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    let c = b - b;
    return c;
}
fn main() -> i64 {
    let r = calc(2);
    println(r;
    return 0;
}


fn calc(b: i64) -> i64 {
    let c = b - b;
    return c;
}
fn main() -> i64 {
    let r = calc(3);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    return b - b;
}
fn main() -> i64 {
    let r = calc(3);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    let c = b - b;
    return c;
}
fn main( -> i64 {
    let r = calc(3);
    println(r);
    return 0;
}


fn calc(b: i64) -> i64 {
    let c = b - b;
    return c;
}
fn main() -> i64 {
    let r = calc(8);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    return b - b;
}
fn main() -> i64 {
    let r = calc(8);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    let c = b - b;
    return c;
}
fn main( -> i64 {
    let r = calc(8);
    println(r);
    return 0;
}


fn calc(b: i64) -> i64 {
    let c = b - b;
    return c;
}
fn main() -> i64 {
    let r = calc(5);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    return b - b;
}
fn main() -> i64 {
    let r = calc(5);
    println(r);
    return 0;
}


fn calc(a: i64) -> i64 {
    let t = a;
    t = t * 6 * a + a;
    return t;
}
fn main() -> i64 {
    let r = calc(3);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    return (a * 6 * a + a);
}
fn main() -> i64 {
    let r = calc(3);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    let c = (a * 6 * a + a);
    return c;
}
fn main() -> i64 {
    let r = calc(3);
    println(r);
    return 0;
}

fn calc(a: i64 -> i64 {
    let t = a;
    t = t * 6 * a + a;
    return t;
}
fn main() -> i64 {
    let r = calc(3);
    println(r);
    return 0;
}


fn calc(c: i64) -> i64 {
    let c = (2 + c * 7);
    return c;
}
fn main() -> i64 {
    let r = calc(7);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    let t = 2;
    t = t + c * 7;
    return t;
}
fn main() -> i64 {
    let r = calc(7);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    return (2 + c * 7);
}
fn main() -> i64 {
    let r = calc(7);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    let c = (2 + c * 7);
    return c;
}
fn main() -> i64 {
    let r = calc(7);
    println(r;
    return 0;
}


fn calc(d: i64, e: i64) -> i64 {
    let t = (d * d + d + e);
    t = t - (d + e - d);
    return t;
}
fn main() -> i64 {
    let r = calc(11, 9);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    let c = ((d * d + d + e) - (d + e - d));
    return c;
}
fn main() -> i64 {
    let r = calc(11, 9);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    return ((d * d + d + e) - (d + e - d));
}
fn main() -> i64 {
    let r = calc(11, 9);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    let t = (d * d + d + e);
    t = t - (d + e - d);
    return t;
}
fn main( -> i64 {
    let r = calc(11, 9);
    println(r);
    return 0;
}


fn calc(c: i64) -> i64 {
    return c + c;
}
fn main() -> i64 {
    let r = calc(9);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    let c = c + c;
    return c;
}
fn main() -> i64 {
    let r = calc(9);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    return c - c;
}
fn main() -> i64 {
    let r = calc(9);
    println(r);
    return 0;
}


fn calc(c: i64) -> i64 {
    return c + c;
}
fn main() -> i64 {
    let r = calc(1);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    let c = c + c;
    return c;
}
fn main() -> i64 {
    let r = calc(1);
    println(r);
    return 0;
}


fn calc(c: i64) -> i64 {
    return c + c;
}
fn main() -> i64 {
    let r = calc(3);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    let c = c + c;
    return c;
}
fn main() -> i64 {
    let r = calc(3);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    return c - c;
}
fn main() -> i64 {
    let r = calc(3);
    println(r);
    return 0;
}


fn calc(c: i64) -> i64 {
    return c + c;
}
fn main() -> i64 {
    let r = calc(5);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    let c = c + c;
    return c;
}
fn main() -> i64 {
    let r = calc(5);
    println(r);
    return 0;
}


fn calc(c: i64) -> i64 {
    return c + c;
}
fn main() -> i64 {
    let r = calc(11);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    let c = c + c;
    return c;
}
fn main() -> i64 {
    let r = calc(11);
    println(r);
    return 0;
}

fn calc(c: i64 -> i64 {
    return c + c;
}
fn main() -> i64 {
    let r = calc(11);
    println(r);
    return 0;
}


fn calc(c: i64) -> i64 {
    return c + c;
}
fn main() -> i64 {
    let r = calc(7);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    let c = c + c;
    return c;
}
fn main() -> i64 {
    let r = calc(7);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    return c - c;
}
fn main() -> i64 {
    let r = calc(7);
    println(r);
    return 0;
}


fn calc(c: i64) -> i64 {
    return c + c;
}
fn main() -> i64 {
    let r = calc(8);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    let c = c + c;
    return c;
}
fn main() -> i64 {
    let r = calc(8);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    return c - c;
}
fn main() -> i64 {
    let r = calc(8);
    println(r);
    return 0;
}


fn calc(c: i64) -> i64 {
    return c + c;
}
fn main() -> i64 {
    let r = calc(10);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    let c = c + c;
    return c;
}
fn main() -> i64 {
    let r = calc(10);
    println(r);
    return 0;
}

fn calc(c: i64 -> i64 {
    return c + c;
}
fn main() -> i64 {
    let r = calc(10);
    println(r);
    return 0;
}


fn calc(c: i64) -> i64 {
    return c + c;
}
fn main() -> i64 {
    let r = calc(2);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    let c = c + c;
    return c;
}
fn main() -> i64 {
    let r = calc(2);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    return c - c;
}
fn main() -> i64 {
    let r = calc(2);
    println(r);
    return 0;
}


fn calc(c: i64) -> i64 {
    return c + c;
}
fn main() -> i64 {
    let r = calc(12);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    let c = c + c;
    return c;
}
fn main() -> i64 {
    let r = calc(12);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    return c - c;
}
fn main() -> i64 {
    let r = calc(12);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64, e: i64) -> i64 {
    return (3 - e * b);
}
fn main() -> i64 {
    let r = calc(4, 5, 12);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64, e: i64) -> i64 {
    let t = 3;
    t = t - e * b;
    return t;
}
fn main() -> i64 {
    let r = calc(4, 5, 12);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64, e: i64) -> i64 {
    let c = (3 - e * b);
    return c;
}
fn main() -> i64 {
    let r = calc(4, 5, 12);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64, e: i64) -> i64 {
    return (3 + e * b);
}
fn main() -> i64 {
    let r = calc(4, 5, 12);
    println(r);
    return 0;
}


fn calc(a: i64, d: i64, e: i64) -> i64 {
    let c = (0 + (9 - d + d));
    return c;
}
fn main() -> i64 {
    let r = calc(1, 7, 1);
    println(r);
    return 0;
}

fn calc(a: i64, d: i64, e: i64) -> i64 {
    let t = 0;
    t = t + (9 - d + d);
    return t;
}
fn main() -> i64 {
    let r = calc(1, 7, 1);
    println(r);
    return 0;
}


fn calc(a: i64, b: i64, e: i64) -> i64 {
    return a - 2;
}
fn main() -> i64 {
    let r = calc(12, 9, 0);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64, e: i64) -> i64 {
    let c = a - 2;
    return c;
}
fn main() -> i64 {
    let r = calc(12, 9, 0);
    println(r);
    return 0;
}

fn calc(e: i64, b: i64, a: i64) -> i64 {
    return a - 2;
}
fn main() -> i64 {
    let r = calc(12, 9, 0);
    println(r);
    return 0;
}


fn calc(c: i64, d: i64, e: i64) -> i64 {
    return (e + (d * 6 + e));
}
fn main() -> i64 {
    let r = calc(2, 8, 4);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64, e: i64) -> i64 {
    let c = (e + (d * 6 + e));
    return c;
}
fn main() -> i64 {
    let r = calc(2, 8, 4);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64, e: i64) -> i64 {
    let t = e;
    t = t + (d * 6 + e);
    return t;
}
fn main() -> i64 {
    let r = calc(2, 8, 4);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64, e: i64) -> i64 {
    return (e + (d + 6 + e));
}
fn main() -> i64 {
    let r = calc(2, 8, 4);
    println(r);
    return 0;
}


fn calc(a: i64) -> i64 {
    let c = ((2 * a * 6) + 3);
    return c;
}
fn main() -> i64 {
    let r = calc(12);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    let t = (2 * a * 6);
    t = t + 3;
    return t;
}
fn main() -> i64 {
    let r = calc(12);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    return ((2 * a * 6) + 3);
}
fn main() -> i64 {
    let r = calc(12);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    let c = ((2 + a * 6) + 3);
    return c;
}
fn main() -> i64 {
    let r = calc(12);
    println(r);
    return 0;
}


fn calc(a: i64, c: i64, d: i64) -> i64 {
    let c = d;
    return c;
}
fn main() -> i64 {
    let r = calc(12, 7, 2);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64, d: i64) -> i64 {
    return d;
}
fn main() -> i64 {
    let r = calc(12, 7, 2);
    println(r);
    return 0;
}

fn calc(d: i64, c: i64, a: i64) -> i64 {
    let c = d;
    return c;
}
fn main() -> i64 {
    let r = calc(12, 7, 2);
    println(r);
    return 0;
}


fn calc(a: i64, c: i64, d: i64) -> i64 {
    let c = d;
    return c;
}
fn main() -> i64 {
    let r = calc(7, 7, 5);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64, d: i64) -> i64 {
    return d;
}
fn main() -> i64 {
    let r = calc(7, 7, 5);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64, d: i64 -> i64 {
    let c = d;
    return c;
}
fn main() -> i64 {
    let r = calc(7, 7, 5);
    println(r);
    return 0;
}


fn calc(a: i64, c: i64, d: i64) -> i64 {
    let c = d;
    return c;
}
fn main() -> i64 {
    let r = calc(0, 3, 0);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64, d: i64) -> i64 {
    return d;
}
fn main() -> i64 {
    let r = calc(0, 3, 0);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64, d: i64) -> i64 {
    let c = d;
    return c;
}
fn main() -> i64 {
    let r = calc(0, 3, 0;
    println(r);
    return 0;
}


fn calc(a: i64, c: i64, d: i64) -> i64 {
    let c = d;
    return c;
}
fn main() -> i64 {
    let r = calc(12, 1, 7);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64, d: i64) -> i64 {
    return d;
}
fn main() -> i64 {
    let r = calc(12, 1, 7);
    println(r);
    return 0;
}

fn calc(a: i64, d: i64, c: i64) -> i64 {
    let c = d;
    return c;
}
fn main() -> i64 {
    let r = calc(12, 1, 7);
    println(r);
    return 0;
}


fn calc(a: i64, c: i64, d: i64) -> i64 {
    let c = d;
    return c;
}
fn main() -> i64 {
    let r = calc(0, 12, 0);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64, d: i64) -> i64 {
    return d;
}
fn main() -> i64 {
    let r = calc(0, 12, 0);
    println(r);
    return 0;
}

fn calc(a: i64, d: i64, c: i64) -> i64 {
    let c = d;
    return c;
}
fn main() -> i64 {
    let r = calc(0, 12, 0);
    println(r);
    return 0;
}


fn calc(a: i64, c: i64, d: i64) -> i64 {
    let c = d;
    return c;
}
fn main() -> i64 {
    let r = calc(7, 11, 8);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64, d: i64) -> i64 {
    return d;
}
fn main() -> i64 {
    let r = calc(7, 11, 8);
    println(r);
    return 0;
}

fn calc(a: i64, d: i64, c: i64) -> i64 {
    let c = d;
    return c;
}
fn main() -> i64 {
    let r = calc(7, 11, 8);
    println(r);
    return 0;
}


fn calc(a: i64, c: i64, d: i64) -> i64 {
    let c = d;
    return c;
}
fn main() -> i64 {
    let r = calc(8, 11, 12);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64, d: i64) -> i64 {
    return d;
}
fn main() -> i64 {
    let r = calc(8, 11, 12);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64, d: i64 -> i64 {
    let c = d;
    return c;
}
fn main() -> i64 {
    let r = calc(8, 11, 12);
    println(r);
    return 0;
}


fn calc(a: i64, c: i64, d: i64) -> i64 {
    let c = d;
    return c;
}
fn main() -> i64 {
    let r = calc(1, 8, 11);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64, d: i64) -> i64 {
    return d;
}
fn main() -> i64 {
    let r = calc(1, 8, 11);
    println(r);
    return 0;
}


fn calc(d: i64, e: i64) -> i64 {
    return d * d;
}
fn main() -> i64 {
    let r = calc(1, 5);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    let c = d * d;
    return c;
}
fn main() -> i64 {
    let r = calc(1, 5);
    println(r);
    return 0;
}

fn calc(e: i64, d: i64) -> i64 {
    return d * d;
}
fn main() -> i64 {
    let r = calc(1, 5);
    println(r);
    return 0;
}


fn calc(d: i64, e: i64) -> i64 {
    return d * d;
}
fn main() -> i64 {
    let r = calc(6, 6);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    let c = d * d;
    return c;
}
fn main() -> i64 {
    let r = calc(6, 6);
    println(r);
    return 0;
}


fn calc(d: i64, e: i64) -> i64 {
    return d * d;
}
fn main() -> i64 {
    let r = calc(7, 1);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    let c = d * d;
    return c;
}
fn main() -> i64 {
    let r = calc(7, 1);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    return d * d;
}
fn main( -> i64 {
    let r = calc(7, 1);
    println(r);
    return 0;
}


fn calc(a: i64, b: i64) -> i64 {
    return 8 - 6;
}
fn main() -> i64 {
    let r = calc(4, 5);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64) -> i64 {
    let c = 8 - 6;
    return c;
}
fn main() -> i64 {
    let r = calc(4, 5);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64) -> i64 {
    return 8 + 6;
}
fn main() -> i64 {
    let r = calc(4, 5);
    println(r);
    return 0;
}


fn calc(c: i64) -> i64 {
    let c = (c + c * 9 + c);
    return c;
}
fn main() -> i64 {
    let r = calc(5);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    let t = c;
    t = t + c * 9 + c;
    return t;
}
fn main() -> i64 {
    let r = calc(5);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    return (c + c * 9 + c);
}
fn main() -> i64 {
    let r = calc(5);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    let c = (c - c * 9 + c);
    return c;
}
fn main() -> i64 {
    let r = calc(5);
    println(r);
    return 0;
}


fn calc(a: i64, b: i64) -> i64 {
    let c = (a - (a + 6 * a));
    return c;
}
fn main() -> i64 {
    let r = calc(6, 6);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64) -> i64 {
    return (a - (a + 6 * a));
}
fn main() -> i64 {
    let r = calc(6, 6);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64) -> i64 {
    let t = a;
    t = t - (a + 6 * a);
    return t;
}
fn main() -> i64 {
    let r = calc(6, 6);
    println(r);
    return 0;
}


fn calc(c: i64, d: i64) -> i64 {
    let t = (d * d * d + 4);
    t = t + (c + d - d + 1);
    return t;
}
fn main() -> i64 {
    let r = calc(4, 4);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    return ((d * d * d + 4) + (c + d - d + 1));
}
fn main() -> i64 {
    let r = calc(4, 4);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    let c = ((d * d * d + 4) + (c + d - d + 1));
    return c;
}
fn main() -> i64 {
    let r = calc(4, 4);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    let t = (d * d * d + 4);
    t = t + (c + d - d + 1);
    return t;
}
fn main() -> i64 {
    let r = calc(4, 4;
    println(r);
    return 0;
}


fn calc(a: i64, c: i64, e: i64) -> i64 {
    return 4 + e;
}
fn main() -> i64 {
    let r = calc(5, 2, 3);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64, e: i64) -> i64 {
    let c = 4 + e;
    return c;
}
fn main() -> i64 {
    let r = calc(5, 2, 3);
    println(r);
    return 0;
}

fn calc(e: i64, c: i64, a: i64) -> i64 {
    return 4 + e;
}
fn main() -> i64 {
    let r = calc(5, 2, 3);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64) -> i64 {
    let c = ((b * c * 4 * c) + (0 * 6 - c));
    return c;
}
fn main() -> i64 {
    let r = calc(2, 3);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    let t = (b * c * 4 * c);
    t = t + (0 * 6 - c);
    return t;
}
fn main() -> i64 {
    let r = calc(2, 3);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64 -> i64 {
    let c = ((b * c * 4 * c) + (0 * 6 - c));
    return c;
}
fn main() -> i64 {
    let r = calc(2, 3);
    println(r);
    return 0;
}


fn calc(c: i64) -> i64 {
    return (c * 1 * c);
}
fn main() -> i64 {
    let r = calc(11);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    let t = c;
    t = t * 1 * c;
    return t;
}
fn main() -> i64 {
    let r = calc(11);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    let c = (c * 1 * c);
    return c;
}
fn main() -> i64 {
    let r = calc(11);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    return (c * 2 * c);
}
fn main() -> i64 {
    let r = calc(11);
    println(r);
    return 0;
}


fn calc(c: i64) -> i64 {
    return (c * 6 * c);
}
fn main() -> i64 {
    let r = calc(7);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    let t = c;
    t = t * 6 * c;
    return t;
}
fn main() -> i64 {
    let r = calc(7);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    let c = (c * 6 * c);
    return c;
}
fn main() -> i64 {
    let r = calc(7);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    return (c * 6 * c;
}
fn main() -> i64 {
    let r = calc(7);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64) -> i64 {
    let t = 5;
    t = t * b * b + b;
    return t;
}
fn main() -> i64 {
    let r = calc(3, 6);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    let c = (5 * b * b + b);
    return c;
}
fn main() -> i64 {
    let r = calc(3, 6);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    return (5 * b * b + b);
}
fn main() -> i64 {
    let r = calc(3, 6);
    println(r);
    return 0;
}

fn calc(c: i64, b: i64) -> i64 {
    let t = 5;
    t = t * b * b + b;
    return t;
}
fn main() -> i64 {
    let r = calc(3, 6);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64, d: i64) -> i64 {
    let c = (d - d * b - c);
    return c;
}
fn main() -> i64 {
    let r = calc(5, 8, 4);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64, d: i64) -> i64 {
    return (d - d * b - c);
}
fn main() -> i64 {
    let r = calc(5, 8, 4);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64, d: i64) -> i64 {
    let t = d;
    t = t - d * b - c;
    return t;
}
fn main() -> i64 {
    let r = calc(5, 8, 4);
    println(r);
    return 0;
}

fn calc(d: i64, c: i64, b: i64) -> i64 {
    let c = (d - d * b - c);
    return c;
}
fn main() -> i64 {
    let r = calc(5, 8, 4);
    println(r);
    return 0;
}


fn calc(c: i64, e: i64) -> i64 {
    let c = (e - c * e);
    return c;
}
fn main() -> i64 {
    let r = calc(5, 8);
    println(r);
    return 0;
}

fn calc(c: i64, e: i64) -> i64 {
    let t = e;
    t = t - c * e;
    return t;
}
fn main() -> i64 {
    let r = calc(5, 8);
    println(r);
    return 0;
}

fn calc(c: i64, e: i64) -> i64 {
    return (e - c * e);
}
fn main() -> i64 {
    let r = calc(5, 8);
    println(r);
    return 0;
}

fn calc(c: i64, e: i64) -> i64 {
    let c = (e - c * e);
    return c;
}
fn main() -> i64 {
    let r = calc(5, 9);
    println(r);
    return 0;
}


fn calc(a: i64, d: i64) -> i64 {
    let t = 1;
    t = t * d - d * d;
    return t;
}
fn main() -> i64 {
    let r = calc(10, 1);
    println(r);
    return 0;
}

fn calc(a: i64, d: i64) -> i64 {
    return (1 * d - d * d);
}
fn main() -> i64 {
    let r = calc(10, 1);
    println(r);
    return 0;
}

fn calc(a: i64, d: i64) -> i64 {
    let c = (1 * d - d * d);
    return c;
}
fn main() -> i64 {
    let r = calc(10, 1);
    println(r);
    return 0;
}

fn calc(a: i64, d: i64) -> i64 {
    let t = 1;
    t = t * d + d * d;
    return t;
}
fn main() -> i64 {
    let r = calc(10, 1);
    println(r);
    return 0;
}


fn calc(c: i64, d: i64, e: i64) -> i64 {
    let t = (e + c * 1 - 0);
    t = t + (d + 8);
    return t;
}
fn main() -> i64 {
    let r = calc(5, 2, 8);
    println(r);
    return 0;
}


fn calc(b: i64, d: i64, e: i64) -> i64 {
    let t = (9 * b - b);
    t = t * (b * 1 - 5);
    return t;
}
fn main() -> i64 {
    let r = calc(3, 8, 6);
    println(r);
    return 0;
}


fn calc(b: i64) -> i64 {
    let t = b;
    t = t * b * 3 + 5;
    return t;
}
fn main() -> i64 {
    let r = calc(9);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    return (b * b * 3 + 5);
}
fn main() -> i64 {
    let r = calc(9);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    let c = (b * b * 3 + 5);
    return c;
}
fn main() -> i64 {
    let r = calc(9);
    println(r);
    return 0;
}

fn calc(b: i64 -> i64 {
    let t = b;
    t = t * b * 3 + 5;
    return t;
}
fn main() -> i64 {
    let r = calc(9);
    println(r);
    return 0;
}


fn calc(e: i64) -> i64 {
    let t = e;
    t = t * (5 + e * 9);
    return t;
}
fn main() -> i64 {
    let r = calc(0);
    println(r);
    return 0;
}

fn calc(e: i64) -> i64 {
    let c = (e * (5 + e * 9));
    return c;
}
fn main() -> i64 {
    let r = calc(0);
    println(r);
    return 0;
}

fn calc(e: i64) -> i64 {
    return (e * (5 + e * 9));
}
fn main() -> i64 {
    let r = calc(0);
    println(r);
    return 0;
}


fn calc(c: i64, d: i64) -> i64 {
    return (c + d - d);
}
fn main() -> i64 {
    let r = calc(10, 1);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    let t = c;
    t = t + d - d;
    return t;
}
fn main() -> i64 {
    let r = calc(10, 1);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    let c = (c + d - d);
    return c;
}
fn main() -> i64 {
    let r = calc(10, 1);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    return (c + d - d);
}
fn main() -> i64 {
    let r = calc(9, 1);
    println(r);
    return 0;
}


fn calc(c: i64, d: i64) -> i64 {
    return (c + 5 * 8 * 9);
}
fn main() -> i64 {
    let r = calc(7, 5);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    let t = c;
    t = t + 5 * 8 * 9;
    return t;
}
fn main() -> i64 {
    let r = calc(7, 5);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    let c = (c + 5 * 8 * 9);
    return c;
}
fn main() -> i64 {
    let r = calc(7, 5);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    return (c + 5 * 9 * 9);
}
fn main() -> i64 {
    let r = calc(7, 5);
    println(r);
    return 0;
}


fn calc(a: i64, e: i64) -> i64 {
    let c = (e + (e * 7 * a));
    return c;
}
fn main() -> i64 {
    let r = calc(6, 12);
    println(r);
    return 0;
}

fn calc(a: i64, e: i64) -> i64 {
    let t = e;
    t = t + (e * 7 * a);
    return t;
}
fn main() -> i64 {
    let r = calc(6, 12);
    println(r);
    return 0;
}

fn calc(a: i64, e: i64) -> i64 {
    return (e + (e * 7 * a));
}
fn main() -> i64 {
    let r = calc(6, 12);
    println(r);
    return 0;
}

fn calc(a: i64, e: i64) -> i64 {
    let c = (e - (e * 7 * a));
    return c;
}
fn main() -> i64 {
    let r = calc(6, 12);
    println(r);
    return 0;
}


fn calc(a: i64) -> i64 {
    let t = 4;
    t = t * 8 + 1;
    return t;
}
fn main() -> i64 {
    let r = calc(6);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    return (4 * 8 + 1);
}
fn main() -> i64 {
    let r = calc(6);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    let c = (4 * 8 + 1);
    return c;
}
fn main() -> i64 {
    let r = calc(6);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    let t = 4;
    t = t * 8 - 1;
    return t;
}
fn main() -> i64 {
    let r = calc(6);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64) -> i64 {
    return b * 6;
}
fn main() -> i64 {
    let r = calc(7, 9);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    let c = b * 6;
    return c;
}
fn main() -> i64 {
    let r = calc(7, 9);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    return b + 6;
}
fn main() -> i64 {
    let r = calc(7, 9);
    println(r);
    return 0;
}


fn calc(a: i64, b: i64) -> i64 {
    return (7 + (b * b - a));
}
fn main() -> i64 {
    let r = calc(4, 8);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64) -> i64 {
    let t = 7;
    t = t + (b * b - a);
    return t;
}
fn main() -> i64 {
    let r = calc(4, 8);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64) -> i64 {
    let c = (7 + (b * b - a));
    return c;
}
fn main() -> i64 {
    let r = calc(4, 8);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64) -> i64 {
    return (7 + (b * b - a));
}
fn main() -> i64 {
    let r = calc(4, 8);
    println(r;
    return 0;
}


fn calc(a: i64, b: i64, e: i64) -> i64 {
    return 0 * e;
}
fn main() -> i64 {
    let r = calc(12, 4, 5);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64, e: i64) -> i64 {
    let c = 0 * e;
    return c;
}
fn main() -> i64 {
    let r = calc(12, 4, 5);
    println(r);
    return 0;
}


fn calc(a: i64, b: i64, e: i64) -> i64 {
    return 8 * e;
}
fn main() -> i64 {
    let r = calc(9, 7, 2);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64, e: i64) -> i64 {
    let c = 8 * e;
    return c;
}
fn main() -> i64 {
    let r = calc(9, 7, 2);
    println(r);
    return 0;
}


fn calc(c: i64, e: i64) -> i64 {
    let t = (e + 7 + e + e);
    t = t + 7;
    return t;
}
fn main() -> i64 {
    let r = calc(3, 3);
    println(r);
    return 0;
}

fn calc(c: i64, e: i64) -> i64 {
    return ((e + 7 + e + e) + 7);
}
fn main() -> i64 {
    let r = calc(3, 3);
    println(r);
    return 0;
}

fn calc(c: i64, e: i64) -> i64 {
    let c = ((e + 7 + e + e) + 7);
    return c;
}
fn main() -> i64 {
    let r = calc(3, 3);
    println(r);
    return 0;
}

fn calc(c: i64, e: i64 -> i64 {
    let t = (e + 7 + e + e);
    t = t + 7;
    return t;
}
fn main() -> i64 {
    let r = calc(3, 3);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64) -> i64 {
    let c = ((3 + b * b + 7) + 5);
    return c;
}
fn main() -> i64 {
    let r = calc(0, 5);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    let t = (3 + b * b + 7);
    t = t + 5;
    return t;
}
fn main() -> i64 {
    let r = calc(0, 5);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    return ((3 + b * b + 7) + 5);
}
fn main() -> i64 {
    let r = calc(0, 5);
    println(r);
    return 0;
}


fn calc(a: i64, c: i64) -> i64 {
    return ((a * c * c + c) + a);
}
fn main() -> i64 {
    let r = calc(3, 1);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64) -> i64 {
    let t = (a * c * c + c);
    t = t + a;
    return t;
}
fn main() -> i64 {
    let r = calc(3, 1);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64) -> i64 {
    let c = ((a * c * c + c) + a);
    return c;
}
fn main() -> i64 {
    let r = calc(3, 1);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64) -> i64 {
    return ((a + c * c + c) + a);
}
fn main() -> i64 {
    let r = calc(3, 1);
    println(r);
    return 0;
}


fn calc(d: i64) -> i64 {
    let c = ((d - 5 + d - d) * (6 + d + 0 - d));
    return c;
}
fn main() -> i64 {
    let r = calc(10);
    println(r);
    return 0;
}

fn calc(d: i64) -> i64 {
    return ((d - 5 + d - d) * (6 + d + 0 - d));
}
fn main() -> i64 {
    let r = calc(10);
    println(r);
    return 0;
}

fn calc(d: i64) -> i64 {
    let t = (d - 5 + d - d);
    t = t * (6 + d + 0 - d);
    return t;
}
fn main() -> i64 {
    let r = calc(10);
    println(r);
    return 0;
}

fn calc(d: i64) -> i64 {
    let c = ((d - 5 + d - d) * (6 + d + 0 - d));
    return c;
}
fn main() -> i64 {
    let r = calc(10;
    println(r);
    return 0;
}


fn calc(c: i64) -> i64 {
    let t = (1 * 0 * c + c);
    t = t + (c * c - 9 * c);
    return t;
}
fn main() -> i64 {
    let r = calc(7);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    return ((1 * 0 * c + c) + (c * c - 9 * c));
}
fn main() -> i64 {
    let r = calc(7);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    let c = ((1 * 0 * c + c) + (c * c - 9 * c));
    return c;
}
fn main() -> i64 {
    let r = calc(7);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    let t = (1 * 0 * c + c);
    t = t + (c * c - 9 * c);
    return t;
}
fn main() -> i64 {
    let r = calc(7;
    println(r);
    return 0;
}


fn calc(b: i64, d: i64) -> i64 {
    let c = ((1 * 5 * d) * (d - b + d + 0));
    return c;
}
fn main() -> i64 {
    let r = calc(1, 1);
    println(r);
    return 0;
}

fn calc(b: i64, d: i64) -> i64 {
    let t = (1 * 5 * d);
    t = t * (d - b + d + 0);
    return t;
}
fn main() -> i64 {
    let r = calc(1, 1);
    println(r);
    return 0;
}


fn calc(c: i64, e: i64) -> i64 {
    return ((e * e * 3 * e) * c);
}
fn main() -> i64 {
    let r = calc(2, 9);
    println(r);
    return 0;
}

fn calc(c: i64, e: i64) -> i64 {
    let c = ((e * e * 3 * e) * c);
    return c;
}
fn main() -> i64 {
    let r = calc(2, 9);
    println(r);
    return 0;
}

fn calc(c: i64, e: i64) -> i64 {
    let t = (e * e * 3 * e);
    t = t * c;
    return t;
}
fn main() -> i64 {
    let r = calc(2, 9);
    println(r);
    return 0;
}

fn calc(c: i64, e: i64) -> i64 {
    return ((e + e * 3 * e) * c);
}
fn main() -> i64 {
    let r = calc(2, 9);
    println(r);
    return 0;
}


fn calc(a: i64, b: i64, e: i64) -> i64 {
    let c = b - a;
    return c;
}
fn main() -> i64 {
    let r = calc(12, 2, 6);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64, e: i64) -> i64 {
    return b - a;
}
fn main() -> i64 {
    let r = calc(12, 2, 6);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64, e: i64) -> i64 {
    let c = b - a;
    return c;
}
fn main() -> i64 {
    let r = calc(12, 2, 6);
    println(r;
    return 0;
}


fn calc(c: i64) -> i64 {
    return (c + c * c);
}
fn main() -> i64 {
    let r = calc(12);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    let c = (c + c * c);
    return c;
}
fn main() -> i64 {
    let r = calc(12);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    let t = c;
    t = t + c * c;
    return t;
}
fn main() -> i64 {
    let r = calc(12);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    return (c + c + c);
}
fn main() -> i64 {
    let r = calc(12);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64) -> i64 {
    let c = ((c * c * 8 - 2) * (c - b + c));
    return c;
}
fn main() -> i64 {
    let r = calc(3, 6);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    return ((c * c * 8 - 2) * (c - b + c));
}
fn main() -> i64 {
    let r = calc(3, 6);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    let t = (c * c * 8 - 2);
    t = t * (c - b + c);
    return t;
}
fn main() -> i64 {
    let r = calc(3, 6);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    let c = ((c * c * 7 - 2) * (c - b + c));
    return c;
}
fn main() -> i64 {
    let r = calc(3, 6);
    println(r);
    return 0;
}


fn calc(c: i64) -> i64 {
    let c = ((c - c + c * 2) * c);
    return c;
}
fn main() -> i64 {
    let r = calc(4);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    let t = (c - c + c * 2);
    t = t * c;
    return t;
}
fn main() -> i64 {
    let r = calc(4);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    return ((c - c + c * 2) * c);
}
fn main() -> i64 {
    let r = calc(4);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    let c = ((c + c + c * 2) * c);
    return c;
}
fn main() -> i64 {
    let r = calc(4);
    println(r);
    return 0;
}


fn calc(a: i64, c: i64, e: i64) -> i64 {
    let t = 6;
    t = t * (2 + e + e);
    return t;
}
fn main() -> i64 {
    let r = calc(9, 0, 11);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64, e: i64) -> i64 {
    let c = (6 * (2 + e + e));
    return c;
}
fn main() -> i64 {
    let r = calc(9, 0, 11);
    println(r);
    return 0;
}

fn calc(e: i64, c: i64, a: i64) -> i64 {
    let t = 6;
    t = t * (2 + e + e);
    return t;
}
fn main() -> i64 {
    let r = calc(9, 0, 11);
    println(r);
    return 0;
}


fn calc(a: i64, c: i64, d: i64) -> i64 {
    let t = 1;
    t = t - (a * a * d * a);
    return t;
}
fn main() -> i64 {
    let r = calc(10, 1, 12);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64, d: i64) -> i64 {
    let c = (1 - (a * a * d * a));
    return c;
}
fn main() -> i64 {
    let r = calc(10, 1, 12);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64, d: i64) -> i64 {
    let t = 1;
    t = t - (a * a * d * a);
    return t;
}
fn main() -> i64 {
    let r = calc(10, 1, 12;
    println(r);
    return 0;
}


fn calc(b: i64, e: i64) -> i64 {
    return (b + e * b - b);
}
fn main() -> i64 {
    let r = calc(8, 9);
    println(r);
    return 0;
}

fn calc(b: i64, e: i64) -> i64 {
    let c = (b + e * b - b);
    return c;
}
fn main() -> i64 {
    let r = calc(8, 9);
    println(r);
    return 0;
}

fn calc(b: i64, e: i64) -> i64 {
    let t = b;
    t = t + e * b - b;
    return t;
}
fn main() -> i64 {
    let r = calc(8, 9);
    println(r);
    return 0;
}

fn calc(b: i64, e: i64) -> i64 {
    return (b + e * b - b);
}
fn main( -> i64 {
    let r = calc(8, 9);
    println(r);
    return 0;
}


fn calc(b: i64, e: i64) -> i64 {
    return ((e + b * b) + (2 * e + b * 6));
}
fn main() -> i64 {
    let r = calc(6, 8);
    println(r);
    return 0;
}

fn calc(b: i64, e: i64) -> i64 {
    let c = ((e + b * b) + (2 * e + b * 6));
    return c;
}
fn main() -> i64 {
    let r = calc(6, 8);
    println(r);
    return 0;
}

fn calc(b: i64, e: i64) -> i64 {
    let t = (e + b * b);
    t = t + (2 * e + b * 6);
    return t;
}
fn main() -> i64 {
    let r = calc(6, 8);
    println(r);
    return 0;
}

fn calc(e: i64, b: i64) -> i64 {
    return ((e + b * b) + (2 * e + b * 6));
}
fn main() -> i64 {
    let r = calc(6, 8);
    println(r);
    return 0;
}


fn calc(a: i64, b: i64, d: i64) -> i64 {
    let c = 2 + d;
    return c;
}
fn main() -> i64 {
    let r = calc(3, 1, 10);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64, d: i64) -> i64 {
    return 2 + d;
}
fn main() -> i64 {
    let r = calc(3, 1, 10);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64, d: i64 -> i64 {
    let c = 2 + d;
    return c;
}
fn main() -> i64 {
    let r = calc(3, 1, 10);
    println(r);
    return 0;
}


fn calc(e: i64) -> i64 {
    let t = 7;
    t = t * (e * 1 + 1 * e);
    return t;
}
fn main() -> i64 {
    let r = calc(11);
    println(r);
    return 0;
}

fn calc(e: i64) -> i64 {
    let c = (7 * (e * 1 + 1 * e));
    return c;
}
fn main() -> i64 {
    let r = calc(11);
    println(r);
    return 0;
}

fn calc(e: i64) -> i64 {
    return (7 * (e * 1 + 1 * e));
}
fn main() -> i64 {
    let r = calc(11);
    println(r);
    return 0;
}

fn calc(e: i64) -> i64 {
    let t = 7;
    t = t * (e * 1 + 1 * e);
    return t;
}
fn main() -> i64 {
    let r = calc(11);
    println(r;
    return 0;
}


fn calc(c: i64, e: i64) -> i64 {
    let t = e;
    t = t - c + c * c;
    return t;
}
fn main() -> i64 {
    let r = calc(5, 5);
    println(r);
    return 0;
}

fn calc(c: i64, e: i64) -> i64 {
    return (e - c + c * c);
}
fn main() -> i64 {
    let r = calc(5, 5);
    println(r);
    return 0;
}

fn calc(c: i64, e: i64) -> i64 {
    let c = (e - c + c * c);
    return c;
}
fn main() -> i64 {
    let r = calc(5, 5);
    println(r);
    return 0;
}

fn calc(c: i64, e: i64) -> i64 {
    let t = e;
    t = t - c - c * c;
    return t;
}
fn main() -> i64 {
    let r = calc(5, 5);
    println(r);
    return 0;
}


fn calc(d: i64) -> i64 {
    let c = ((5 + d * 5) + d);
    return c;
}
fn main() -> i64 {
    let r = calc(11);
    println(r);
    return 0;
}

fn calc(d: i64) -> i64 {
    return ((5 + d * 5) + d);
}
fn main() -> i64 {
    let r = calc(11);
    println(r);
    return 0;
}

fn calc(d: i64) -> i64 {
    let t = (5 + d * 5);
    t = t + d;
    return t;
}
fn main() -> i64 {
    let r = calc(11);
    println(r);
    return 0;
}

fn calc(d: i64) -> i64 {
    let c = ((5 + d + 5) + d);
    return c;
}
fn main() -> i64 {
    let r = calc(11);
    println(r);
    return 0;
}


fn calc(a: i64) -> i64 {
    return (a + a + a + 7);
}
fn main() -> i64 {
    let r = calc(12);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    let c = (a + a + a + 7);
    return c;
}
fn main() -> i64 {
    let r = calc(12);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    let t = a;
    t = t + a + a + 7;
    return t;
}
fn main() -> i64 {
    let r = calc(12);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    return (a - a + a + 7);
}
fn main() -> i64 {
    let r = calc(12);
    println(r);
    return 0;
}


fn calc(a: i64, b: i64, c: i64) -> i64 {
    let t = (6 - a * 5 + 4);
    t = t + b;
    return t;
}
fn main() -> i64 {
    let r = calc(11, 4, 5);
    println(r);
    return 0;
}


fn calc(e: i64) -> i64 {
    return (3 * e);
}
fn main() -> i64 {
    let r = calc(10);
    println(r);
    return 0;
}

fn calc(e: i64) -> i64 {
    let t = 3;
    t = t * e;
    return t;
}
fn main() -> i64 {
    let r = calc(10);
    println(r);
    return 0;
}

fn calc(e: i64) -> i64 {
    let c = (3 * e);
    return c;
}
fn main() -> i64 {
    let r = calc(10);
    println(r);
    return 0;
}

fn calc(e: i64) -> i64 {
    return (3 * e;
}
fn main() -> i64 {
    let r = calc(10);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64) -> i64 {
    let c = 9 * 7;
    return c;
}
fn main() -> i64 {
    let r = calc(1, 6);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    return 9 * 7;
}
fn main() -> i64 {
    let r = calc(1, 6);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64) -> i64 {
    let c = 4 * 4;
    return c;
}
fn main() -> i64 {
    let r = calc(12, 4);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    return 4 * 4;
}
fn main() -> i64 {
    let r = calc(12, 4);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    let c = 4 * 4;
    return c;
}
fn main() -> i64 {
    let r = calc(12, 4);
    println(r;
    return 0;
}


fn calc(b: i64, c: i64) -> i64 {
    let c = 7 * 0;
    return c;
}
fn main() -> i64 {
    let r = calc(1, 8);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    return 7 * 0;
}
fn main() -> i64 {
    let r = calc(1, 8);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    let c = 7 + 0;
    return c;
}
fn main() -> i64 {
    let r = calc(1, 8);
    println(r);
    return 0;
}


fn calc(d: i64, e: i64) -> i64 {
    let c = (2 + d * d * d);
    return c;
}
fn main() -> i64 {
    let r = calc(5, 9);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    let t = 2;
    t = t + d * d * d;
    return t;
}
fn main() -> i64 {
    let r = calc(5, 9);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    return (2 + d * d * d);
}
fn main() -> i64 {
    let r = calc(5, 9);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    let c = (1 + d * d * d);
    return c;
}
fn main() -> i64 {
    let r = calc(5, 9);
    println(r);
    return 0;
}


fn calc(a: i64, c: i64) -> i64 {
    let t = c;
    t = t - a - c;
    return t;
}
fn main() -> i64 {
    let r = calc(3, 8);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64) -> i64 {
    let c = (c - a - c);
    return c;
}
fn main() -> i64 {
    let r = calc(3, 8);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64) -> i64 {
    return (c - a - c);
}
fn main() -> i64 {
    let r = calc(3, 8);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64) -> i64 {
    let t = c;
    t = t + a - c;
    return t;
}
fn main() -> i64 {
    let r = calc(3, 8);
    println(r);
    return 0;
}


fn calc(a: i64, c: i64) -> i64 {
    let t = (a - c * c * 0);
    t = t + (5 + 6 * c + 4);
    return t;
}
fn main() -> i64 {
    let r = calc(9, 2);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64) -> i64 {
    let c = ((a - c * c * 0) + (5 + 6 * c + 4));
    return c;
}
fn main() -> i64 {
    let r = calc(9, 2);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64) -> i64 {
    let t = (a - c + c * 0);
    t = t + (5 + 6 * c + 4);
    return t;
}
fn main() -> i64 {
    let r = calc(9, 2);
    println(r);
    return 0;
}


fn calc(a: i64, c: i64, e: i64) -> i64 {
    let t = (3 * e + a * e);
    t = t + c;
    return t;
}
fn main() -> i64 {
    let r = calc(10, 1, 2);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64, e: i64) -> i64 {
    let c = ((3 * e + a * e) + c);
    return c;
}
fn main() -> i64 {
    let r = calc(10, 1, 2);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64, e: i64) -> i64 {
    return ((3 * e + a * e) + c);
}
fn main() -> i64 {
    let r = calc(10, 1, 2);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64, e: i64) -> i64 {
    let t = (3 * e + a * e);
    t = t + c;
    return t;
}
fn main() -> i64 {
    let r = calc(10, 0, 2);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64, d: i64) -> i64 {
    let c = (d * c * b);
    return c;
}
fn main() -> i64 {
    let r = calc(7, 10, 0);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64, d: i64) -> i64 {
    return (d * c * b);
}
fn main() -> i64 {
    let r = calc(7, 10, 0);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64, d: i64) -> i64 {
    let t = d;
    t = t * c * b;
    return t;
}
fn main() -> i64 {
    let r = calc(7, 10, 0);
    println(r);
    return 0;
}


fn calc(a: i64, b: i64, c: i64) -> i64 {
    return a;
}
fn main() -> i64 {
    let r = calc(0, 4, 9);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64, c: i64) -> i64 {
    let c = a;
    return c;
}
fn main() -> i64 {
    let r = calc(0, 4, 9);
    println(r);
    return 0;
}