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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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


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

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


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

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


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

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

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


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

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

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

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


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

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

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


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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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


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

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


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

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

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

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


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

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

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

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


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

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

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


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

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


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

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


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

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


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

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

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


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

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


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

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


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

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


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

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


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

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

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


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

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

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


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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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


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

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


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

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


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

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


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

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

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


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

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

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


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

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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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

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


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

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


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

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


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

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

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


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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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


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

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

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


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

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


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

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

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


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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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


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

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

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


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

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

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


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

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


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

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


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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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