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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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


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

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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(1);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(1);
    println(r;
    return 0;
}


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


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


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(9);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 + 2;
}
fn main() -> i64 {
    let r = f1(9);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(0);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(5);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64 -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(5);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(3);
    println(r);
    return 0;
}


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


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(5);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main( -> i64 {
    let r = f1(5);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(3);
    println(r);
    return 0;
}

fn f0(x: i64 -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(3);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(5);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 0;
}

fn f0(x: i64 -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 0;
}


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


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

fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 2;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 0;
}


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


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

fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(1);
    println(r);
    return 1;
}


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

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


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

fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 + 3;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 0;
}


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


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

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


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 0;
}

fn f0(x: i64 -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(7);
    println(r);
    return 0;
}

fn f0(x: i64 -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(7);
    println(r);
    return 0;
}


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


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


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(4);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 + 3;
}
fn main() -> i64 {
    let r = f1(4);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(7);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(0);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(5);
    println(r);
    return 0;
}

fn f0(x: i64 -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(5);
    println(r);
    return 0;
}


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

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


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(3);
    println(r);
    return 0;
}

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


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(8);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64 -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(8);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(2);
    println(r);
    return 0;
}


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

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


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(6;
    println(r);
    return 0;
}


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


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(8);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(8;
    println(r);
    return 0;
}


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

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


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(3);
    println(r);
    return 0;
}

fn f0(x: i64 -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(3);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(3);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(4);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 + 3;
}
fn main() -> i64 {
    let r = f1(4);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(4);
    println(r);
    return 0;
}

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


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(8);
    println(r);
    return 0;
}


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


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


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(8);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 + 3;
}
fn main() -> i64 {
    let r = f1(8);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(9);
    println(r);
    return 0;
}

fn f0(x: i64 -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(9);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(1);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(1);
    println(r);
    return 0;
}


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

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


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(0);
    println(r);
    return 0;
}

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


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

fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 + 2;
}
fn main() -> i64 {
    let r = f1(4);
    println(r);
    return 0;
}


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

fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 1;
}


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(5);
    println(r);
    return 0;
}


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


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


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

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


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

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


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


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(9);
    println(r);
    return 0;
}


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

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


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(8);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 + 2;
}
fn main() -> i64 {
    let r = f1(8);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(9);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(9);
    println(r);
    return 1;
}


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

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


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(7);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(4);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(5);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(5);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(7);
    println(r);
    return 0;
}


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

fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 + 3;
}
fn main() -> i64 {
    let r = f1(5);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(5);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(2);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 + 3;
}
fn main() -> i64 {
    let r = f1(2);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(9);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main( -> i64 {
    let r = f1(9);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(2);
    println(r);
    return 0;
}


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

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


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


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(9);
    println(r);
    return 0;
}


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


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


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(9);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(9;
    println(r);
    return 0;
}


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

fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(1);
    println(r);
    return 1;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(6);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 2;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(3);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main( -> i64 {
    let r = f1(3);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(5);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main( -> i64 {
    let r = f1(5);
    println(r);
    return 0;
}


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


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(1);
    println(r);
    return 0;
}


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

fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(5);
    println(r);
    return 1;
}


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


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(1);
    println(r);
    return 0;
}


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

fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 + 2;
}
fn main() -> i64 {
    let r = f1(8);
    println(r);
    return 0;
}


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


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(8);
    println(r);
    return 0;
}

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


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(5);
    println(r);
    return 0;
}


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

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


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(1);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main( -> i64 {
    let r = f1(1);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(9);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 + 3;
}
fn main() -> i64 {
    let r = f1(9);
    println(r);
    return 0;
}


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

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


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


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(2);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64 -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(2);
    println(r);
    return 0;
}


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

fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 3;
}
fn main() -> i64 {
    let r = f1(3);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(3);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(8);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 + 3;
}
fn main() -> i64 {
    let r = f1(8);
    println(r);
    return 0;
}


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

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


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


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(5);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(5);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(5);
    println(r;
    return 0;
}


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


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


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


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(9);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 + 2;
}
fn main() -> i64 {
    let r = f1(9);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(3);
    println(r);
    return 0;
}

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


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

fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 + 3;
}
fn main() -> i64 {
    let r = f1(9);
    println(r);
    return 0;
}


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

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


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(7);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(2);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(0);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(0);
    println(r;
    return 0;
}


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


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(0);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(0);
    println(r;
    return 0;
}


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

fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 + 2;
}
fn main() -> i64 {
    let r = f1(2);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(3);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64 -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(3);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(4);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(4);
    println(r);
    return 1;
}


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


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

fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 + 2;
}
fn main() -> i64 {
    let r = f1(2);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(3);
    println(r);
    return 0;
}

fn f0(x: i64 -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(3);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(2);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(2);
    println(r);
    return 1;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(9);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(1);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64 -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(1);
    println(r);
    return 0;
}


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


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


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(0);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main( -> i64 {
    let r = f1(0);
    println(r);
    return 0;
}


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

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


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


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(4);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(4);
    println(r);
    return 0;
}


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

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


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(1);
    println(r);
    return 0;
}


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


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(8);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(2);
    println(r);
    return 0;
}


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

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


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


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

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


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

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


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(9);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64 -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 0;
}


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

fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 + 3;
}
fn main() -> i64 {
    let r = f1(1);
    println(r);
    return 0;
}


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


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

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


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


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(7);
    println(r);
    return 0;
}

fn f0(x: i64 -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(7);
    println(r);
    return 0;
}


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

fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 + 3;
}
fn main() -> i64 {
    let r = f1(1);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 1;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(1);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(7);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(7);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(8);
    println(r);
    return 0;
}

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


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(7);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(7;
    println(r);
    return 0;
}


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


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

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


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


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


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


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(1);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(1);
    println(r;
    return 0;
}


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

fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(9);
    println(r);
    return 1;
}


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


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 0;
}

fn f0(x: i64 -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(4);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(4;
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(7);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(7);
    println(r);
    return 1;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(4);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(4);
    println(r;
    return 0;
}


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


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

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


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


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

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


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


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


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(7);
    println(r);
    return 0;
}

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


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

fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(9);
    println(r);
    return 1;
}


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(5);
    println(r);
    return 0;
}


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

fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 2;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn main() -> i64 {
    let r = f1(1);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(7);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main( -> i64 {
    let r = f1(7);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(4);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64 -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(4);
    println(r);
    return 0;
}


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

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


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(4);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(1);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn main() -> i64 {
    let r = f1(1);
    println(r);
    return 1;
}


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn f2(x: i64 -> i64 {
    return f1 + 4;
}
fn main() -> i64 {
    let r = f2(6);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn f2(x: i64 -> i64 {
    return f1 + 7;
}
fn main() -> i64 {
    let r = f2(1);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn f2(x: i64) -> i64 {
    return f1 + 5;
}
fn main() -> i64 {
    let r = f2(0);
    println(r;
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 4;
}
fn f2(x: i64) -> i64 {
    return f1 + 1;
}
fn main() -> i64 {
    let r = f2(0);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn f2(x: i64) -> i64 {
    return f1 + 2;
}
fn main( -> i64 {
    let r = f2(9);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 4;
}
fn f2(x: i64) -> i64 {
    return f1 + 1;
}
fn main() -> i64 {
    let r = f2(5);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64 -> i64 {
    return f0 + 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 1;
}
fn main() -> i64 {
    let r = f2(9);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64 -> i64 {
    return f0 + 8;
}
fn f2(x: i64) -> i64 {
    return f1 + 7;
}
fn main() -> i64 {
    let r = f2(0);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn f2(x: i64) -> i64 {
    return f1 + 3;
}
fn main() -> i64 {
    let r = f2(0;
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64 -> i64 {
    return f0 + 4;
}
fn f2(x: i64) -> i64 {
    return f1 + 0;
}
fn main() -> i64 {
    let r = f2(5);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 9;
}
fn f2(x: i64) -> i64 {
    return f1 + 9;
}
fn main() -> i64 {
    let r = f2(5;
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 + 3;
}
fn f2(x: i64) -> i64 {
    return f1 + 7;
}
fn main() -> i64 {
    let r = f2(7;
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 + 5;
}
fn f2(x: i64) -> i64 {
    return f1 + 3;
}
fn main() -> i64 {
    let r = f2(2);
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn f2(x: i64) -> i64 {
    return f1 + 1;
}
fn main() -> i64 {
    let r = f2(0);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 + 3;
}
fn f2(x: i64) -> i64 {
    return f1 + 3;
}
fn main( -> i64 {
    let r = f2(4);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 + 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 6;
}
fn main( -> i64 {
    let r = f2(3);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn f2(x: i64) -> i64 {
    return f1 + 1;
}
fn main( -> i64 {
    let r = f2(3);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn f2(x: i64) -> i64 {
    return f1 + 0;
}
fn main( -> i64 {
    let r = f2(8);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 + 4;
}
fn f2(x: i64 -> i64 {
    return f1 + 1;
}
fn main() -> i64 {
    let r = f2(4);
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn f2(x: i64) -> i64 {
    return f1 + 9;
}
fn main() -> i64 {
    let r = f2(7);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64 -> i64 {
    return f0 + 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 1;
}
fn main() -> i64 {
    let r = f2(5);
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 5;
}
fn f2(x: i64) -> i64 {
    return f1 + 0;
}
fn main() -> i64 {
    let r = f2(0);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn f2(x: i64) -> i64 {
    return f1 + 9;
}
fn main() -> i64 {
    let r = f2(5);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64 -> i64 {
    return f0 + 6;
}
fn f2(x: i64) -> i64 {
    return f1 + 9;
}
fn main() -> i64 {
    let r = f2(1);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 4;
}
fn f2(x: i64) -> i64 {
    return f1 + 9;
}
fn main() -> i64 {
    let r = f2(2);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64 -> i64 {
    return f0 + 3;
}
fn f2(x: i64) -> i64 {
    return f1 + 1;
}
fn main() -> i64 {
    let r = f2(8);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn f2(x: i64) -> i64 {
    return f1 + 5;
}
fn main( -> i64 {
    let r = f2(5);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 + 0;
}
fn f2(x: i64 -> i64 {
    return f1 + 5;
}
fn main() -> i64 {
    let r = f2(7);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 3;
}
fn f2(x: i64) -> i64 {
    return f1 + 8;
}
fn main() -> i64 {
    let r = f2(9;
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 + 8;
}
fn f2(x: i64) -> i64 {
    return f1 + 4;
}
fn main() -> i64 {
    let r = f2(0);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64 -> i64 {
    return f0 + 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 7;
}
fn main() -> i64 {
    let r = f2(1);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 + 3;
}
fn f2(x: i64 -> i64 {
    return f1 + 2;
}
fn main() -> i64 {
    let r = f2(4);
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 8;
}
fn f2(x: i64) -> i64 {
    return f1 + 1;
}
fn main() -> i64 {
    let r = f2(1);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn f2(x: i64) -> i64 {
    return f1 + 2;
}
fn main( -> i64 {
    let r = f2(6);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn f2(x: i64) -> i64 {
    return f1 + 6;
}
fn main() -> i64 {
    let r = f2(1;
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 9;
}
fn f2(x: i64) -> i64 {
    return f1 + 2;
}
fn main() -> i64 {
    let r = f2(3);
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 + 9;
}
fn f2(x: i64) -> i64 {
    return f1 + 2;
}
fn main() -> i64 {
    let r = f2(0);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn f2(x: i64) -> i64 {
    return f1 + 8;
}
fn main() -> i64 {
    let r = f2(9;
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 + 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 3;
}
fn main() -> i64 {
    let r = f2(5;
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn f2(x: i64 -> i64 {
    return f1 + 5;
}
fn main() -> i64 {
    let r = f2(8);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn f2(x: i64) -> i64 {
    return f1 + 7;
}
fn main() -> i64 {
    let r = f2(0);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 8;
}
fn f2(x: i64) -> i64 {
    return f1 + 2;
}
fn main() -> i64 {
    let r = f2(6;
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 + 4;
}
fn f2(x: i64) -> i64 {
    return f1 + 6;
}
fn main( -> i64 {
    let r = f2(5);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn f2(x: i64) -> i64 {
    return f1 + 7;
}
fn main() -> i64 {
    let r = f2(8;
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64 -> i64 {
    return f0 + 6;
}
fn f2(x: i64) -> i64 {
    return f1 + 4;
}
fn main() -> i64 {
    let r = f2(8);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn f2(x: i64) -> i64 {
    return f1 + 1;
}
fn main() -> i64 {
    let r = f2(7;
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 8;
}
fn f2(x: i64) -> i64 {
    return f1 + 3;
}
fn main() -> i64 {
    let r = f2(1);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64 -> i64 {
    return f0 + 3;
}
fn f2(x: i64) -> i64 {
    return f1 + 1;
}
fn main() -> i64 {
    let r = f2(3);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn f2(x: i64 -> i64 {
    return f1 + 7;
}
fn main() -> i64 {
    let r = f2(9);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64 -> i64 {
    return f0 + 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 1;
}
fn main() -> i64 {
    let r = f2(8);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 + 4;
}
fn f2(x: i64 -> i64 {
    return f1 + 4;
}
fn main() -> i64 {
    let r = f2(4);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64 -> i64 {
    return f0 + 5;
}
fn f2(x: i64) -> i64 {
    return f1 + 4;
}
fn main() -> i64 {
    let r = f2(5);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn f2(x: i64) -> i64 {
    return f1 + 6;
}
fn main() -> i64 {
    let r = f2(9);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64 -> i64 {
    return f0 + 9;
}
fn f2(x: i64) -> i64 {
    return f1 + 3;
}
fn main() -> i64 {
    let r = f2(3);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 3;
}
fn f2(x: i64) -> i64 {
    return f1 + 3;
}
fn main() -> i64 {
    let r = f2(1;
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 + 0;
}
fn f2(x: i64) -> i64 {
    return f1 + 5;
}
fn main() -> i64 {
    let r = f2(1);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 + 5;
}
fn f2(x: i64) -> i64 {
    return f1 + 6;
}
fn main( -> i64 {
    let r = f2(7);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64 -> i64 {
    return f0 + 7;
}
fn f2(x: i64) -> i64 {
    return f1 + 2;
}
fn main() -> i64 {
    let r = f2(9);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 5;
}
fn f2(x: i64 -> i64 {
    return f1 + 3;
}
fn main() -> i64 {
    let r = f2(1);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn f2(x: i64 -> i64 {
    return f1 + 4;
}
fn main() -> i64 {
    let r = f2(1);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn f2(x: i64) -> i64 {
    return f1 + 4;
}
fn main() -> i64 {
    let r = f2(7;
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64 -> i64 {
    return f0 + 0;
}
fn f2(x: i64) -> i64 {
    return f1 + 6;
}
fn main() -> i64 {
    let r = f2(2);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 + 9;
}
fn f2(x: i64) -> i64 {
    return f1 + 3;
}
fn main( -> i64 {
    let r = f2(3);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn f2(x: i64) -> i64 {
    return f1 + 3;
}
fn main() -> i64 {
    let r = f2(9);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 0;
}
fn f2(x: i64) -> i64 {
    return f1 + 7;
}
fn main( -> i64 {
    let r = f2(5);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn f2(x: i64) -> i64 {
    return f1 + 6;
}
fn main() -> i64 {
    let r = f2(8);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn f2(x: i64 -> i64 {
    return f1 + 7;
}
fn main() -> i64 {
    let r = f2(5);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 9;
}
fn f2(x: i64) -> i64 {
    return f1 + 0;
}
fn main( -> i64 {
    let r = f2(1);
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 + 9;
}
fn f2(x: i64) -> i64 {
    return f1 + 0;
}
fn main() -> i64 {
    let r = f2(4);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 5;
}
fn f2(x: i64) -> i64 {
    return f1 + 0;
}
fn main() -> i64 {
    let r = f2(8;
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 + 8;
}
fn f2(x: i64) -> i64 {
    return f1 + 5;
}
fn main() -> i64 {
    let r = f2(7);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn f2(x: i64) -> i64 {
    return f1 + 0;
}
fn main() -> i64 {
    let r = f2(5);
    println(r;
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 + 8;
}
fn f2(x: i64) -> i64 {
    return f1 + 6;
}
fn main() -> i64 {
    let r = f2(9);
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 + 0;
}
fn f2(x: i64) -> i64 {
    return f1 + 8;
}
fn main() -> i64 {
    let r = f2(0);
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 5;
}
fn f2(x: i64) -> i64 {
    return f1 + 0;
}
fn main() -> i64 {
    let r = f2(4);
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 + 9;
}
fn f2(x: i64) -> i64 {
    return f1 + 7;
}
fn main() -> i64 {
    let r = f2(5);
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 + 8;
}
fn f2(x: i64) -> i64 {
    return f1 + 5;
}
fn main() -> i64 {
    let r = f2(2);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 + 3;
}
fn f2(x: i64) -> i64 {
    return f1 + 1;
}
fn main() -> i64 {
    let r = f2(5);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 + 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 7;
}
fn main( -> i64 {
    let r = f2(1);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 0;
}
fn f2(x: i64 -> i64 {
    return f1 + 6;
}
fn main() -> i64 {
    let r = f2(9);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn f2(x: i64 -> i64 {
    return f1 + 2;
}
fn main() -> i64 {
    let r = f2(4);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 + 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 0;
}
fn main() -> i64 {
    let r = f2(2);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn f2(x: i64 -> i64 {
    return f1 + 7;
}
fn main() -> i64 {
    let r = f2(7);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64 -> i64 {
    return f0 + 7;
}
fn f2(x: i64) -> i64 {
    return f1 + 9;
}
fn main() -> i64 {
    let r = f2(6);
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 9;
}
fn f2(x: i64) -> i64 {
    return f1 + 8;
}
fn main() -> i64 {
    let r = f2(2);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 + 5;
}
fn f2(x: i64) -> i64 {
    return f1 + 7;
}
fn main( -> i64 {
    let r = f2(6);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 5;
}
fn f2(x: i64) -> i64 {
    return f1 + 9;
}
fn main() -> i64 {
    let r = f2(2;
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn f2(x: i64) -> i64 {
    return f1 + 2;
}
fn main() -> i64 {
    let r = f2(4;
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn f2(x: i64) -> i64 {
    return f1 + 8;
}
fn main() -> i64 {
    let r = f2(6;
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 5;
}
fn f2(x: i64) -> i64 {
    return f1 + 8;
}
fn main() -> i64 {
    let r = f2(4);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn f2(x: i64) -> i64 {
    return f1 + 7;
}
fn main() -> i64 {
    let r = f2(0);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 4;
}
fn f2(x: i64) -> i64 {
    return f1 + 2;
}
fn main() -> i64 {
    let r = f2(1;
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 + 8;
}
fn f2(x: i64) -> i64 {
    return f1 + 9;
}
fn main() -> i64 {
    let r = f2(3);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 + 3;
}
fn f2(x: i64 -> i64 {
    return f1 + 6;
}
fn main() -> i64 {
    let r = f2(2);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(8);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64 -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(1);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(7;
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64 -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(3);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64 -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(4);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main( -> i64 {
    let r = f2(5);
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(8);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64 -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(5);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64 -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(6);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(4);
    println(r;
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(5);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(3);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(5);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main( -> i64 {
    let r = f2(1);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64 -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(6);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(8);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64 -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(9);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64 -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(1);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(2;
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64 -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(8);
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(5);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(9);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main( -> i64 {
    let r = f2(2);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(7);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(0);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64 -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(6);
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(4);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(7);
    println(r;
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(7);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64 -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(7);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64 -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(7);
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(1);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64 -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(0);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64 -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(6);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64 -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(0);
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(9);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64 -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(1);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(1);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(6);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(3);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64 -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(9);
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(0);
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(5);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64 -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(1);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main( -> i64 {
    let r = f2(2);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(5);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(1);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64 -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(2);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(0;
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(5);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64 -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(9);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64 -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(6);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64 -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(6);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(2);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(5);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(0);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main( -> i64 {
    let r = f2(0);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(5);
    println(r;
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(6);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main( -> i64 {
    let r = f2(4);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64 -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(1);
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(4);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main( -> i64 {
    let r = f2(0);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64 -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(5);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64 -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(6);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64 -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(4);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64 -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(0);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main( -> i64 {
    let r = f2(7);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64 -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(5);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main( -> i64 {
    let r = f2(4);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main( -> i64 {
    let r = f2(3);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(1;
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(4);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(2);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(5);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64 -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(7);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(5;
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64 -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(8);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(2;
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(1);
    println(r;
    return 0;
}