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

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

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


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

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


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

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


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

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

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

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


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

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

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

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

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

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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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


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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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


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

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

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


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

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


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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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


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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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


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

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

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

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


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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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


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

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

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

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


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

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


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

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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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


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

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

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


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

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

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


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

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

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


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

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


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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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


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

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


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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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