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

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

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

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


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

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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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


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

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


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

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

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


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

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


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

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


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

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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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


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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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


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

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

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


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

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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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


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

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

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

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


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

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


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

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

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


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

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


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

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

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


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

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


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

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


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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

fn calc(e: i64) -> i64 {
    return e + e;
}
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(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 {
    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(0);
    println(r);
    return 0;
}


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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


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

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

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


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

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


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

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

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

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


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

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

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


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

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


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

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


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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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


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

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


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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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