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

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

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


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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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


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

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


fn calc(b: i64) -> i64 {
    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(6);
    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(3);
    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 0;
}


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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

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


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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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


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

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

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


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

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

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

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


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

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

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

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


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(4, 8);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(4, 8);
    println(r);
    return 0;
}

fn run(b: i64, a: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(4, 8);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(2, 12);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(2, 12);
    println(r);
    return 0;
}

fn run(b: i64, a: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(2, 12);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(11, 14);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(11, 14);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s - b - i;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(11, 14);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(11, 12);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(11, 12);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s - b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(11, 12);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(1, 7);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(1, 7);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(0, 7);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(7, 9);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(7, 9);
    println(r);
    return 0;
}

fn run(b: i64, a: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(7, 9);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(14, 12);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(14, 12);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(5, 5);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(5, 5);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b + i;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(5, 5);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(12, 8);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(12, 8);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(9, 4);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(9, 4);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(9, 4);
    println(r;
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(5, 14);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(5, 14);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b + i;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(5, 14);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(13, 12);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(13, 12);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(0, 1);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(0, 1);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s - b - i;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(0, 1);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(12, 10);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(12, 10);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(12, 10);
    println(r);
    return 1;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(2, 4);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(2, 4);
    println(r);
    return 0;
}

fn run(a: i64, b: i64 -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(2, 4);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(9, 5);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(9, 5);
    println(r);
    return 0;
}

fn run(b: i64, a: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(9, 5);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(6, 9);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(6, 9);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main( -> i64 {
    let r = run(6, 9);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(10, 6);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(10, 6);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(6, 7);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(6, 7);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(5, 7);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(9, 1);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(9, 1);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(13, 2);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(13, 2);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(13, 2);
    println(r;
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(13, 13);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(13, 13);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s - b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(13, 13);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(7, 12);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(7, 12);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(10, 8);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(10, 8);
    println(r);
    return 0;
}

fn run(b: i64, a: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(10, 8);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(12, 1);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(12, 1);
    println(r);
    return 0;
}

fn run(b: i64, a: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(12, 1);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(11, 0);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(11, 0);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(3, 4);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(3, 4);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(8, 0);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(8, 0);
    println(r);
    return 0;
}

fn run(b: i64, a: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(8, 0);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(5, 10);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(5, 10);
    println(r);
    return 0;
}

fn run(b: i64, a: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(5, 10);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(0, 0);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(0, 0);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main( -> i64 {
    let r = run(0, 0);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(7, 7);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(7, 7);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(7, 7);
    println(r);
    return 1;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(11, 13);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(11, 13);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 2;
    }
    return s;
}
fn main( -> i64 {
    let r = run(11, 13);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(4, 11);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(4, 11);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b + i;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(4, 11);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(12, 13);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(12, 13);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(9, 5);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(9, 5);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(10, 14);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(10, 14);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s - b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(10, 14);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(4, 9);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(4, 9);
    println(r);
    return 0;
}

fn run(b: i64, a: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(4, 9);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(0, 8);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(0, 8);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s - b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(0, 8);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(0, 1);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(0, 1);
    println(r);
    return 0;
}

fn run(b: i64, a: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(0, 1);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(12, 11);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(12, 11);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(3, 0);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(3, 0);
    println(r);
    return 0;
}

fn run(b: i64, a: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(3, 0);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(5, 8);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(5, 8);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(5, 8);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(12, 14);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(12, 14);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(12, 14;
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(6, 1);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(6, 1);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(10, 11);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(10, 11);
    println(r);
    return 0;
}

fn run(b: i64, a: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(10, 11);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(3, 12);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(3, 12);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(2, 12);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(11, 11);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(11, 11);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 2;
    }
    return s;
}
fn main( -> i64 {
    let r = run(11, 11);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(3, 11);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(3, 11);
    println(r);
    return 0;
}

fn run(b: i64, a: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(3, 11);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(6, 9);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(6, 9);
    println(r);
    return 0;
}

fn run(b: i64, a: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(6, 9);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(11, 14);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(11, 14);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s - b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(11, 14);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(8, 4);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(8, 4);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(8, 4;
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(1, 0);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(1, 0);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(6, 14);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(6, 14);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b + i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(6, 14);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(3, 10);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(3, 10);
    println(r);
    return 0;
}

fn run(b: i64, a: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(3, 10);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(6, 3);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(6, 3);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(7, 4);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(7, 4);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(1, 14);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(1, 14);
    println(r);
    return 0;
}

fn run(b: i64, a: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(1, 14);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(8, 14);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(8, 14);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s - b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(8, 14);
    println(r);
    return 0;
}


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

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(7, 12);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(7, 12);
    println(r);
    return 1;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(14, 5);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(14, 5);
    println(r);
    return 0;
}

fn run(b: i64, a: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(14, 5);
    println(r);
    return 0;
}


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

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

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


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(6, 6);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(6, 6);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s - b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(6, 6);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(11, 6);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(11, 6);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(8, 1);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(8, 1);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(8, 1;
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(10, 13);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(10, 13);
    println(r);
    return 0;
}

fn run(b: i64, a: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(10, 13);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(11, 7);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(11, 7);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(11, 7);
    println(r);
    return 1;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(3, 13);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(3, 13);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 2;
    }
    return s;
}
fn main( -> i64 {
    let r = run(3, 13);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(14, 0);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(14, 0);
    println(r);
    return 0;
}

fn run(b: i64, a: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(14, 0);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(2, 5);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(2, 5);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(2, 6);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(8, 7);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(8, 7);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(8, 7;
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(6, 10);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(6, 10);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 1;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(6, 10);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(4, 12);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(4, 12);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s - b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(4, 12);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(14, 4);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(14, 4);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(3, 5);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(3, 5);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(3, 5);
    println(r;
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(0, 10);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(0, 10);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        s = s + b - i;
        i = i + 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(1, 10);
    println(r);
    return 0;
}