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

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

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


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

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

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


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

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

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


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

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


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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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


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

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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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


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

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

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


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

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

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


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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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


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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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


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

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

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

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


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

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


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

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


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

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

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


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

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

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


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

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


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

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


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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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