Problem:
Score : 200 points

Problem Statement

Print all the integers that satisfies the following in ascending order:

Among the integers between A and B (inclusive), it is either within the K smallest integers or within the K largest integers.

Constraints

1 \leq A \leq B \leq 10^9

1 \leq K \leq 100

All values in input are integers.

Input

Input is given from Standard Input in the following format:

A B K

Output

Print all the integers that satisfies the condition above in ascending order.

Sample Input 1

3 8 2

Sample Output 1

3
4
7
8

3 is the first smallest integer among the integers between 3 and 8.

4 is the second smallest integer among the integers between 3 and 8.

7 is the second largest integer among the integers between 3 and 8.

8 is the first largest integer among the integers between 3 and 8.

Sample Input 2

4 8 3

Sample Output 2

4
5
6
7
8

Sample Input 3

2 9 100

Sample Output 3

2
3
4
5
6
7
8
9

Solution in Rust (1.15.1) (judge verdict: Accepted)

use std::io::*;
use std::str::FromStr;
use std::cmp::{min, max};
use std::rc::Rc;
use std::mem::swap;

fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin_lock = stdin.lock();
    let s = stdin_lock
        .bytes()
        .map(|c| c.unwrap() as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect::<String>();
    s.parse::<T>().ok().unwrap()
}

static DX: &'static [i32] = &[0, 0, 1, -1];
static DY: &'static [i32] = &[1, -1, 0, 0];

fn dfs(x: usize, y: usize, a: i32, b: i32, dir: usize, map: &Vec<Vec<char>>, gx: usize, gy: usize) -> bool {
    if a < 0 || b < 0 {
        return false;
    }

    if map[y][x] == '#' {
        return false;
    }

    if x == gx && y == gy && a == 0 && b == 0{
        return true;
    }

    let mut ans = false;

    if dir == 0 {
        ans |= dfs(x + 1, y, a, b, 0, &map, gx, gy);
        ans |= dfs(x, y + 1, a, b - 1, 1, &map, gx, gy);
        ans |= dfs(x, y - 1, a - 1, b, 3, &map, gx, gy);
    } else if dir == 1 {
        ans |= dfs(x, y + 1, a, b, 1, &map, gx, gy);
        ans |= dfs(x + 1, y, a - 1, b, 0, &map, gx, gy);
        ans |= dfs(x - 1, y, a, b - 1, 2, &map, gx, gy);
    } else if dir == 2 {
        ans |= dfs(x - 1, y, a, b, 2, &map, gx, gy);
        ans |= dfs(x, y + 1, a - 1, b, 1, &map, gx, gy);
        ans |= dfs(x, y - 1, a, b - 1, 3, &map, gx, gy);
    } else {
        ans |= dfs(x, y - 1, a, b, 3, &map, gx, gy);
        ans |= dfs(x + 1, y, a, b - 1, 0, &map, gx, gy);
        ans |= dfs(x - 1, y, a - 1, b, 2, &map, gx, gy);
    }

    return ans;
}

fn main() {
    let a: i32 = read();
    let b: i32 = read();
    let k: i32 = read();

    for i in a..b + 1 {
        if i < a + k || b - k < i {
            println!("{}", i);
        }
    }
}