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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

fn calc(b: i64) -> i64 {
    return b + 6;
}
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(12);
    println(r);
    return 0;
}


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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

fn calc(c: i64, d: i64, e: i64) -> i64 {
    let c = c - e;
    return c;
}
fn main() -> i64 {
    let r = calc(10, 3, 0;
    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(0);
    println(r);
    return 0;
}

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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


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

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

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

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


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

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


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

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

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

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


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

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

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


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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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


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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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


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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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


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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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

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


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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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