fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
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 + 9;
}
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 + 9;
}
fn main() -> i64 {
    let r = f1(5);
    println(r);
    return 1;
}


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 9;
}
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 + 0;
}
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 + 0;
}
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 + 9;
}
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 + 1;
}
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 + 5;
}
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 + 5;
}
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 + 9;
}
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 + 9;
}
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 + 1;
}
fn main() -> i64 {
    let r = f1(8);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 0;
}
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 + 0;
}
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 + 9;
}
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 + 0;
}
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 + 9;
}
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 + 9;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 1;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
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 + 6;
}
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 + 4;
}
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 + 4;
}
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 + 9;
}
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 + 9;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 1;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 + 8;
}
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 + 1;
}
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 + 1;
}
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 + 7;
}
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 + 6;
}
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 + 4;
}
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 + 4;
}
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 + 7;
}
fn main() -> i64 {
    let r = f1(7);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 + 8;
}
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(1);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
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 + 0;
}
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 + 8;
}
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 + 6;
}
fn f1(x: i64) -> i64 {
    return f0 + 5;
}
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 + 3;
}
fn main() -> i64 {
    let r = f1(7);
    println(r);
    return 0;
}


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


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 + 9;
}
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 + 7;
}
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 + 8;
}
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 + 8;
}
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 + 8;
}
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 + 8;
}
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 + 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 + 0;
}
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 + 0;
}
fn main() -> i64 {
    let r = f1(3);
    println(r);
    return 1;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 0;
}
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 + 0;
}
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(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 + 9;
}
fn f1(x: i64) -> i64 {
    return f0 + 9;
}
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(9);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
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 + 5;
}
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 + 6;
}
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 + 6;
}
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 + 5;
}
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 + 4;
}
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 + 5;
}
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 + 6;
}
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 + 6;
}
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 + 1;
}
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(4);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 9;
}
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 + 9;
}
fn main() -> i64 {
    let r = f1(2);
    println(r);
    return 1;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 8;
}
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 + 6;
}
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 + 5;
}
fn main() -> i64 {
    let r = f1(7);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
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 + 7;
}
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 + 8;
}
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 + 8;
}
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 + 7;
}
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 + 5;
}
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 + 5;
}
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(5);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
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 + 6;
}
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 + 6;
}
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 + 8;
}
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 + 1;
}
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 + 1;
}
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 + 1;
}
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 + 6;
}
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 + 6;
}
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 + 6;
}
fn main() -> i64 {
    let r = f1(8);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
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 + 9;
}
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 + 5;
}
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 + 5;
}
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 + 4;
}
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 + 4;
}
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 + 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 + 1;
}
fn f1(x: i64) -> i64 {
    return f0 + 8;
}
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 + 8;
}
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 + 9;
}
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 + 4;
}
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 + 5;
}
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 + 0;
}
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 + 0;
}
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 + 5;
}
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 + 8;
}
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 + 8;
}
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 + 9;
}
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 + 9;
}
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 + 4;
}
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 + 4;
}
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 + 5;
}
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 + 5;
}
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 + 6;
}
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 + 6;
}
fn main() -> i64 {
    let r = f1(7);
    println(r);
    return 0;
}


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

fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 + 5;
}
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 + 4;
}
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 + 9;
}
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 + 9;
}
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(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 + 5;
}
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 + 6;
}
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 + 6;
}
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 + 5;
}
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(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 + 6;
}
fn f1(x: i64) -> i64 {
    return f0 + 4;
}
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 + 0;
}
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 + 0;
}
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 + 0;
}
fn main() -> i64 {
    let r = f1(0);
    println(r);
    return 1;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 4;
}
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 + 4;
}
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 + 6;
}
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 + 4;
}
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(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 1;
}


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 + 5;
}
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 + 5;
}
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 + 5;
}
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 + 1;
}
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 + 9;
}
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 + 4;
}
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 + 8;
}
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 + 8;
}
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 + 1;
}
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 + 8;
}
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 + 8;
}
fn main() -> i64 {
    let r = f1(3);
    println(r);
    return 1;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 + 9;
}
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 + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
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 + 7;
}
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 + 5;
}
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 + 5;
}
fn main( -> i64 {
    let r = f1(8);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 4;
}
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 + 4;
}
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 + 4;
}
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 + 0;
}
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 + 0;
}
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 + 0;
}
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(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(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 1;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
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 + 7;
}
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 + 8;
}
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 + 9;
}
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 + 7;
}
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 + 7;
}
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 + 6;
}
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(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 + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 8;
}
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 + 6;
}
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 + 7;
}
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 + 7;
}
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 + 0;
}
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 + 8;
}
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 + 4;
}
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 + 5;
}
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 + 5;
}
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 + 6;
}
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 + 8;
}
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 + 4;
}
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 + 9;
}
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 + 6;
}
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 + 6;
}
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 + 1;
}
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 + 1;
}
fn main() -> i64 {
    let r = f1(9);
    println(r);
    return 1;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 4;
}
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 + 1;
}
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 + 6;
}
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 + 6;
}
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(0);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 + 8;
}
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(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(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(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(1);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 4;
}
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 + 6;
}
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 + 6;
}
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(3);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 9;
}
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 + 5;
}
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 + 5;
}
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 + 8;
}
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 + 8;
}
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 + 9;
}
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 + 0;
}
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 + 7;
}
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 + 6;
}
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(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 + 1;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
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 + 1;
}
fn main() -> i64 {
    let r = f1(7);
    println(r);
    return 1;
}


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
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 + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 5;
}
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 + 9;
}
fn f1(x: i64) -> i64 {
    return f0 + 9;
}
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 + 5;
}
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 + 9;
}
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 + 6;
}
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 + 6;
}
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 + 8;
}
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 + 5;
}
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 + 5;
}
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 + 1;
}
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 + 1;
}
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 + 1;
}
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 + 9;
}
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 + 9;
}
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 + 9;
}
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 + 9;
}
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 + 1;
}
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 + 4;
}
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 + 6;
}
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 + 0;
}
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 + 0;
}
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 + 0;
}
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 + 0;
}
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 + 0;
}
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 + 4;
}
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 + 4;
}
fn main() -> i64 {
    let r = f1(3);
    println(r);
    return 1;
}


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 9;
}
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 + 9;
}
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 + 4;
}
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 + 4;
}
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 + 1;
}
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 + 1;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 0;
}


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

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

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


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

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

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


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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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


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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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

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


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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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