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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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


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

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


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

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

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


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

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


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

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


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

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

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


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

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

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

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


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

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

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

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


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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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


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

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

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


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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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


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

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

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


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

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


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

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

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

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


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

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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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


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

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

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


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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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


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

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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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


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

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

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


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

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

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


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

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


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

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

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


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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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


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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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