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

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

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


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

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

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


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

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


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

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

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

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


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

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

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


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

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


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

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

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


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

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


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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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


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

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


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

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

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


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

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

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


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

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

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


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

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


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

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


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

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

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


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

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


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

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

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


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

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


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

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


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

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


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

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

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


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

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

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


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

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


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

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


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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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


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

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

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


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

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


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

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


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

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

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


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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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


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

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

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

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


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

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


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

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

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

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


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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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


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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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


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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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


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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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


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

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

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


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

fn calc(a: i64, b: i64, c: i64) -> i64 {
    let c = 8;
    return c;
}
fn main() -> i64 {
    let r = calc(5, 4, 3);
    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 {
    let t = a;
    t = t - a;
    return t;
}
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(4);
    println(r);
    return 0;
}


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

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

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

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


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

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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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

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

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


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

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


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

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

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

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


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

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

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

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