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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

fn calc(c: i64) -> i64 {
    let c = (c * c * c);
    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(0);
    println(r);
    return 0;
}

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


fn calc(c: i64) -> i64 {
    let c = (c * (c - c + c * 8));
    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 + c * 8);
    return t;
}
fn main() -> i64 {
    let r = calc(8);
    println(r);
    return 0;
}

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

fn calc(c: i64) -> i64 {
    let c = (c * (c + c + c * 8));
    return c;
}
fn main() -> i64 {
    let r = calc(8);
    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(12, 2, 7);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64, e: i64) -> i64 {
    return e + b;
}
fn main() -> i64 {
    let r = calc(12, 2, 7);
    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(12, 2, 6);
    println(r);
    return 0;
}


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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


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

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


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

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


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

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


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

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


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

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

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


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

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


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

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


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

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


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

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


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

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

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


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

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

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


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

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

fn calc(a: i64, c: i64, d: i64) -> i64 {
    let c = ((c - a + 2 + a) + (d * 1 + a + d);
    return c;
}
fn main() -> i64 {
    let r = calc(8, 4, 5);
    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(11);
    println(r);
    return 0;
}

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

fn calc(c: i64) -> i64 {
    let c = (c + c - c + c);
    return c;
}
fn main() -> i64 {
    let r = calc(11);
    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(11);
    println(r);
    return 0;
}


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

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

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


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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


fn calc(a: i64, b: i64, c: i64) -> i64 {
    return b * c;
}
fn main() -> i64 {
    let r = calc(9, 9, 2);
    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(9, 9, 2);
    println(r);
    return 0;
}


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

fn calc(c: i64) -> i64 {
    let c = (c * c - c * 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 - c * c;
    return t;
}
fn main() -> i64 {
    let r = calc(5);
    println(r);
    return 0;
}

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


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

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

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

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


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

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

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


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

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


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

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

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


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

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

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

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


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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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