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, 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(14, 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(14, 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(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 - 1;
    }
    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 - 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(9, 1);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = b;
    while i >= a {
        s = s + a + b - i;
        i = i - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(12, 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(12, 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(12, 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(8, 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(8, 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(8, 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(9, 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(9, 7);
    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(9, 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, 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(4, 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(3, 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(7, 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(7, 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 - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(7, 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, 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(13, 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(13, 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(13, 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(13, 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(13, 14);
    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(2, 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(2, 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(2, 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(5, 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(5, 4);
    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(5, 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(12, 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(12, 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(8, 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(8, 14);
    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, 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, 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(10, 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(10, 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(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 - 2;
    }
    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(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(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 - 2;
    }
    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 - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(2, 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(2, 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(2, 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(2, 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(2, 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(2, 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(8, 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(8, 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, 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(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 - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(9, 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(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(5, 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(5, 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(5, 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(6, 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(6, 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, 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(2, 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(2, 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(2, 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(3, 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(3, 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(3, 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(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 - 1;
    }
    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(2, 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(2, 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(2, 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(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 - 1;
    }
    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(6, 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, 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(10, 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(10, 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(10, 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(10, 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(13, 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(13, 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(13, 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(11, 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(11, 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 - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(11, 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 - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(2, 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(2, 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(2, 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(6, 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(6, 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, 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(14, 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(14, 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(13, 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(13, 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(0, 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(0, 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(0, 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(9, 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(9, 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(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 - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(4, 11);
    println(r);
    return 0;
}

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


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = b;
    while i >= a {
        s = s + a + b - i;
        i = i - 2;
    }
    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 - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(0, 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 - 2;
    }
    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 - 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(2, 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(2, 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(2, 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(6, 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(6, 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(9, 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(9, 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(9, 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(14, 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(14, 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(14, 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, 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(6, 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(6, 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, 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(14, 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(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(3, 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(3, 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(3, 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, 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(10, 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(10, 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(10, 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(10, 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, 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(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(9, 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(9, 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(12, 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(12, 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(12, 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, 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(0, 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(0, 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(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 - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(12, 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 - 2;
    }
    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 - 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(2, 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(2, 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(8, 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(8, 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(8, 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(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 - 2;
    }
    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 - 2;
    }
    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 - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(6, 10);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = b;
    while i >= a {
        let t = a + b - i;
        s = s + t;
        i = i - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(6, 10);
    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(6, 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(14, 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(14, 5);
    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(14, 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(0, 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(0, 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(0, 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(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 - 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(3, 5);
    println(r);
    return 0;
}

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


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

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = b;
    while i >= a {
        let t = a + b - i;
        s = s + t;
        i = i - 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(3, 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(3, 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(13, 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(13, 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(13, 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, 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(13, 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(13, 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, 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(12, 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, 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(6, 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(6, 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(11, 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(11, 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 - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(11, 7);
    println(r);
    return 0;
}


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

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

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


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

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

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


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

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


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = b;
    while i >= a {
        s = s + a + b - i;
        i = i - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(5, 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(5, 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(5, 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, 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(9, 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(9, 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(4, 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(4, 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, 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(7, 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(7, 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(7, 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(11, 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(11, 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(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 - 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(4, 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(4, 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(4, 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(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 - 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 - 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(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 - 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(8, 7);
    println(r);
    return 0;
}

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


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = b;
    while i >= a {
        s = s + a + b - i;
        i = i - 2;
    }
    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 - 2;
    }
    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 - 2;
    }
    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(6, 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(6, 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(6, 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(14, 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(14, 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, 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(10, 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(10, 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(1, 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(1, 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 - 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(1, 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 - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(3, 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(3, 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(3, 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, 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(10, 12);
    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(10, 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(2, 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(2, 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(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 - 2;
    }
    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, 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(5, 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(5, 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(5, 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(1, 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(1, 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(1, 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(10, 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(10, 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(3, 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(3, 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, 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(11, 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(11, 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(11, 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(11, 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(11, 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(3, 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(3, 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(6, 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(6, 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, 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(5, 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(5, 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, 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(11, 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(11, 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(2, 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(2, 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(2, 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, 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(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 - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(9, 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(9, 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(9, 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(1, 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(1, 10);
    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(1, 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(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 - 1;
    }
    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 - 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(12, 8);
    println(r);
    return 0;
}


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

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

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


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

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


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

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = b;
    while i >= a {
        let t = a + b - i;
        s = s + t;
        i = i - 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(12, 14);
    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, 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, 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(8, 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(9, 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(1, 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(1, 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(1, 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(9, 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(9, 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(6, 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(6, 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(7, 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(7, 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(7, 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(12, 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(12, 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(9, 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(9, 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 - 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(9, 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, 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(7, 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(7, 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(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 - 1;
    }
    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 - 0;
    }
    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 - 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(11, 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(11, 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, 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, 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(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 - 0;
    }
    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 - 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(1, 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(1, 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(1, 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(1, 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(1, 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(3, 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(3, 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(3, 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(2, 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(2, 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(2, 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(11, 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(11, 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(11, 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(0, 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(0, 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(0, 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, 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(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(0, 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(0, 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(0, 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, 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(3, 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(3, 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, 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(2, 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(1, 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(1, 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(1, 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(5, 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(5, 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, 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 - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(11, 6);
    println(r);
    return 0;
}

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


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

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

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


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


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = b;
    while i >= a {
        s = s + a + b - i;
        i = i - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(13, 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(13, 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(13, 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, 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(0, 7);
    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(0, 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(2, 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(2, 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(2, 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(14, 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(14, 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(14, 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, 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(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 - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(9, 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(9, 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(9, 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(2, 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(2, 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(2, 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(5, 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(5, 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, 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(4, 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(4, 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(4, 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(11, 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(11, 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, 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(5, 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(5, 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(10, 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(10, 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(10, 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(0, 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(0, 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(9, 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(9, 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, 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(9, 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(9, 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(9, 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(7, 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(7, 10);
    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, 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, 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(4, 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, 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(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 - 1;
    }
    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(13, 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(13, 4);
    println(r);
    return 0;
}