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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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


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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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


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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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


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

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


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

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

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


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

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

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


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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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


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

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

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


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

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


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

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

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


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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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