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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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


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

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

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

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


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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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

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

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


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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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


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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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


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

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

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

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

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

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


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

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

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


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

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


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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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

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


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

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


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

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


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

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

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

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


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

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

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

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


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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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