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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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


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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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


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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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


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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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


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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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


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

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