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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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


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

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


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

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

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


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

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


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

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

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


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

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


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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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


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

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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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


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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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


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

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


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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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


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


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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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 {
    return e * e;
}
fn main() -> i64 {
    let r = calc(1);
    println(r);
    return 1;
}


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

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

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


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

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

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

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