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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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

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


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

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


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

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

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


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

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


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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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