jiahuimbzuai/CoQuIR huggingface dataset:
//  [rust]
//  ____            _                  _                       _       _
// |  _ \ _   _ ___| |_    ___ _ __   | |_ ___ _ __ ___  _ __ | | __ _| |_ ___
// | |_) | | | / __| __|  / __| '_ \  | __/ _ \ '_ ` _ \| '_ \| |/ _` | __/ _ \
// |  _ <| |_| \__ \ |_  | (__| |_) | | ||  __/ | | | | | |_) | | (_| | ||  __/
// |_| \_\\__,_|___/\__|  \___| .__/___\__\___|_| |_| |_| .__/|_|\__,_|\__\___|
//                            |_| |_____|               |_|

//https://github.com/manta1130/Competitive_Programming_Template_Rust

#[macro_use]
mod input {

    use std;
    use std::io;

    const SPLIT_DELIMITER: char = ' ';

    #[macro_export]
    #[allow(unused_macros)]
    macro_rules! input {
    ( $($x:expr ),*) => {
        {
            let temp_str = input_line_str();
            let mut split_result_iter = temp_str.split_whitespace();
                $(
                let buf_split_result = split_result_iter.next();
                let buf_split_result = buf_split_result.unwrap();
                    ($x) = buf_split_result.parse().unwrap();
                )*
        }
    };
}

    #[allow(dead_code)]
    pub fn input_line_str() -> String {
        let mut s = String::new();
        io::stdin().read_line(&mut s).unwrap();
        s.trim().to_string()
    }

    #[allow(dead_code)]
    pub fn p<T>(t: T)
    where
        T: std::fmt::Display,
    {
        println!("{}", t);
    }

    #[allow(dead_code)]
    pub fn input_vector2d<T>(line: usize) -> Vec<Vec<T>>
    where
        T: std::str::FromStr,
    {
        let mut v: Vec<Vec<T>> = Vec::new();

        for _ in 0..line {
            let vec_line = input_vector();
            v.push(vec_line);
        }
        v
    }

    #[allow(dead_code)]
    pub fn input_vector<T>() -> Vec<T>
    where
        T: std::str::FromStr,
    {
        let mut v: Vec<T> = Vec::new();

        let s = input_line_str();
        let split_result = s.split(SPLIT_DELIMITER);
        for z in split_result {
            let buf = match z.parse() {
                Ok(r) => r,
                Err(_) => panic!("Parse Error"),
            };
            v.push(buf);
        }
        v
    }

    #[allow(dead_code)]
    pub fn input_vector_row<T>(n: usize) -> Vec<T>
    where
        T: std::str::FromStr,
    {
        let mut v = Vec::with_capacity(n);
        for _ in 0..n {
            let buf = match input_line_str().parse() {
                Ok(r) => r,
                Err(_) => panic!("Parse Error"),
            };
            v.push(buf);
        }
        v
    }

    pub trait ToCharVec {
        fn to_charvec(&self) -> Vec<char>;
    }

    impl ToCharVec for String {
        fn to_charvec(&self) -> Vec<char> {
            self.to_string().chars().collect::<Vec<_>>()
        }
    }
}

use input::*;

fn main()
{
    let mut n:usize;
    input!(n);
    let mut flag=true;
    while n>0{
        if n%10!=9{
            flag=false;
        }
        n/= 10;
    }
    if flag{
        println!("No")
    }else{
        println!("Yes");
    }
}
//  [swift]
let N=Int(readLine()!)!;print(N/10<9&&N%10<9 ?"No":"Yes")
//  [swift]
import Glibc
extension String: CollectionType {}

//var xt = readLine()!.split(" ").map { Int($0)! }
var n = Int(readLine()!)!
if n % 10 == 9 || n / 10 == 9 {
  print("Yes")
} else {
  print("No")
}
//  [swift]
let N=Int(readLine()!)!;print(N/10<9||N%10<9 ?"No":"Yes")
//  [typescript]
"use strict";

main(require("fs").readFileSync("/dev/stdin", "utf8"));

function main(input) {
  const n = input;

  const ans = n.includes("9") ? 'Yes' : 'No';
  console.log(ans);
}
//  [typescript]
import * as fs from 'fs';

namespace AtCoder {
    export interface Paramable {
        readonly args: string[][];
    }

    export interface Task {
        main(this: Task): void;
    }
}

namespace AtCoder.abc073 {
    export class TaskA implements AtCoder.Task, AtCoder.Paramable {
        public constructor(public readonly args: string[][]) {
        }

        public main(this: TaskA): void {
            const n: string = this.args[0][0];
            const ans: string = n.indexOf('9') > -1 ? 'Yes' : 'No';
            console.log(ans);
        }
    }

    const args: string[][] = fs.readFileSync('/dev/stdin', 'utf8').trim().split('\n').map(r => r.split(' '));
    const task: AtCoder.Task = new TaskA(args);
    task.main();
}
//  [typescript]
const t={input:require('fs').readFileSync('/dev/stdin','utf8').split(/[\s]/),n:(arg:number=0):number|number[]=>{if(arg){const a=[];for(let i=0;i<arg;i++){a.push(t.n())}return a}else{const a=t.input[0];t.input.shift();return Number(a)}},s:(arg:number=0):string|string[]=>{if(arg){const a=[];for(let i=0;i<arg;i++){a.push(t.s())}return a}else{const a=t.input[0];t.input.shift();return String(a)}},c:(arg:number=0):string|string[]=>{if(arg){const a=[];for(let i=0;i<arg;i++){a.push(t.c())}return a}else{let a=t.input[0].split('');const b=a[0];a.shift();if(a.length>0){t.input[0]=a.join('')}else{t.input.shift()}return String(b)}},o:(...arg)=>{console.log(...arg)},abs:(a)=>{return Math.abs(a)},min:(...a)=>{return Math.min(...a)},max:(...a)=>{return Math.max(...a)},floor:(a)=>{return Math.floor(a)},asc:(ar:number[])=>{return ar.sort((a,b)=>{return a-b})},desc:(ar:number[])=>{return ar.sort((a,b)=>{return b-a})},sw:(a,arr:any[],op:'=='|'>='|'>'|'<='|'<'='==')=>{for(let i=0;i<arr.length;i+=2){if(eval(a+op+arr[i]))return arr[i+1];}return arr[arr.length-1]}};
const main=()=>{
let [a,b] = t.c(2)
  t.o(a=='9'||b=='9'?'Yes':'No')
}
main()
//  [typescript]
const main = (input) => {
  input = input.split(' ');
  const N = parseInt(input[0], 10);
  
  if (N%10===9 || N/10==9) {
    console.log("Yes");
  }else{
    console.log("No");
  }
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [python]
a, b, k = map(int, input().split())

t = []

for i in range(k):
    if i+a <= b:
        t.append(i+a)

for i in range(k):
    if b-i >= a:
        t.append(b-i)

y = list(set(t))

for x in sorted(y):
    print(x)
//  [python]
A, B, K = map(int, input().split())

if K*2 > (B-A+1):
    for i in range(A, B+1):
        print(i)
else:
    for j in range(A, A+K):
        print(j)
    for j in range(B-K+1, B+1):
        print(j)
//  [python]
a, b, k = map(int, input().split())
for i in range(k):
  if a+i <= b:
    print(a+i)

for i in range(k):
  if a+k <= b-k+1+i:
    print(b-k+1+i)
//  [python]
a, b, k = map(int, input().split())
l = list(range(a, b+1))
for i in sorted(list(set(l[:k]) | set(l[-k:]))):
    print(i)
//  [python]
a, b, k = map(int, input().split())
l = list(range(a, b+1))
for i in sorted(list(set(l[:k] + l[-k:]))):
    print(i)
//  [python]
a, b, k = map(int, input().split())
l = list(range(a, b+1))
if k != 0:
    for i in range(len(list(set(l[:k] + l[-k:])))):
        print(sorted(list(set(l[:k] + l[-k:])))[i])
else:
    print()
//  [java]
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;

public class Main {
	final int _intMax = Integer.MAX_VALUE; // =2147483647>10^9
	final int _intMin = Integer.MIN_VALUE;
	final long _longMax = Long.MAX_VALUE; // =9223372036854775807L>10^18
	final long _longMin = Long.MIN_VALUE;
	static boolean bElapsed = false;

	void solve() {
		int[] ia = readNums();
		int a = ia[0];
		int b = ia[1];
		int k = ia[2];
		int d = k;
		int e = k;
		for (int i = a; i <= b; i++) {
			if (d > 0) {
				pln(i);
				d--;
			} else {
				if (i < b - k + 1) {
					i = b - k + 1;
				}
				pln(i);
			}
		}
	}

	int pint(String s) {
		return Integer.parseInt(s);
	}

	long plong(String s) {
		return Long.parseLong(s);
	}

	String readLine() {
		try {
			return _in.readLine();
		} catch (IOException e) {
			throw new RuntimeException(e);
		}
	}

	int readNum() {
		String line = readLine();
		return pint(line);
	}

	String[] readFlds() {
		String line = readLine();
		return line.split(" ");
	}

	int[] readNums() {
		String[] flds = readFlds();
		int[] nums = new int[flds.length];
		for (int i = 0; i < flds.length; i++) {
			nums[i] = pint(flds[i]);
		}
		return nums;
	}

	void p(char c) {
		_out.print(c);
	}

	void pln(char c) {
		_out.println(c);
	}

	void p(double d) {
		_out.print(d);
	}

	void pln(double d) {
		_out.println(d);
	}

	void p(long l) {
		_out.print(l);
	}

	void pln(long l) {
		_out.println(l);
	}

	void p(String s) {
		_out.print(s);
	}

	void pln(String s) {
		_out.println(s);
	}

	static BufferedReader _in;
	static PrintWriter _out;

	public static void main(String[] args) {
		long start = System.currentTimeMillis();
		_in = new BufferedReader(new InputStreamReader(System.in));
		_out = new PrintWriter(System.out);
		new Main().solve();
		_out.flush();
		long end = System.currentTimeMillis();
		if (bElapsed) {
			System.err.println((end - start) + "ms");
		}
	}
}
//  [java]
import java.io.*;
import java.util.*;

public class Main {
	public static void main(String[] args) {
		MyScanner sc = new MyScanner();
		out = new PrintWriter(new BufferedOutputStream(System.out));
		
		
		int numA = sc.nextInt(), numB=sc.nextInt(),numK=sc.nextInt();
		int subtraction = numB - numA;
		if (subtraction<numK*2){
			for (int i = numA; i <= numB; i++) {
				out.println(i);
			}
			
		}else {
			for (int i = numA; i < numA+numK; i++) {
				out.println(i);
			}
			for (int i = numB-numK+1; i <= numB; i++) {
				out.println(i);
			}
		}
		out.close();
	}

	//-----------http://codeforces.com/blog/entry/7018---------------------------------
	public static PrintWriter out;

	public static class MyScanner {
		BufferedReader br;
		StringTokenizer st;

		public MyScanner() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		String next() {
			while (st == null || !st.hasMoreElements()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

		int nextInt() {
			return Integer.parseInt(next());
		}

		long nextLong() {
			return Long.parseLong(next());
		}

		double nextDouble() {
			return Double.parseDouble(next());
		}

		String nextLine() {
			String str = "";
			try {
				str = br.readLine();
			} catch (IOException e) {
				e.printStackTrace();
			}
			return str;
		}

	}
	//--------------------------------------------------------

}
//  [java]
import java.util.Scanner;
import java.util.TreeSet;

public class Main {
    public static void main(String[] args) {
        try (Scanner in = new Scanner(System.in)) {
            int A = in.nextInt();
            int B = in.nextInt();
            int K = in.nextInt();

            TreeSet<Integer> set = new TreeSet<>();
            for (int i = A; i < A + K; i++) {
                set.add(i);
            }
            for (int i = B - (K - 1); i <= B; i++) {
                set.add(i);
            }

            for (Integer i : set) {
                System.out.println(i);
            }
        }
    }
}
//  [java]
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        try (Scanner in = new Scanner(System.in)) {
            int A = in.nextInt();
            int B = in.nextInt();
            int K = in.nextInt();

            for (int i = A; i < A + K; i++) {
                System.out.println(i);
            }
            for (int i = B - (K - 1); i <= B; i++) {
                System.out.println(i);
            }
        }
    }
}
//  [java]
import java.util.*;
 
public class Main {
	public static void main(String[] args) throws Exception{
		Scanner sc = new Scanner(System.in);
		int a = sc.nextInt();
        int b = sc.nextInt();
        int m = sc.nextInt();
        ArrayList<Integer> list = new ArrayList<>();
        int suma = a;
        int sumb = b;
        for(int i = a; i < a + m; i++){
        	if(i <= b){
            	list.add(i);
            }
        }
        for(int i = b; i > b - m; i--){
        	if(i >= a){
            	list.add(i);
            }
        }
        Collections.sort(list);
        for(int i = 0; i < list.size(); i++){
        	if(i == 0 || list.get(i - 1) != list.get(i)){
            	System.out.println(list.get(i));
            }
        }
	}
}
//  [cpp]
#include<bits/stdc++.h>
#define F first
#define S second
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> ii;
typedef vector<ii> vii;


int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
	int a, b, k;
	cin >> a >> b >> k;
	set<int> st;
	for (int i = a; i <= min(b, a+k-1); ++i) st.insert(i);
	for (int i = b; i >= max(b-k+1, a); --i) st.insert(i);
	for (int v : st) cout << v << "\n";
    return 0;
}
//  [cpp]
#include <bits/stdc++.h>

using namespace std;

#define INF 1000000000
#define pb(a) push_back(a)
#define vi vector<int>
#define vvi vector<vi>
#define P pair<int,int>
#define all(vec) (vec.begin()),(vec.end())
#define ll long long
#define sz(x) ((int)(x).size())
#define in(x) int x;cin>>x;
#define bit(n) (1<<(n))

#define REP(i, n) for(int i=0, i##_len=(n); i<i##_len; ++i)
#define REPR(i, n) for(int i = n;i >= 0;i--)
#define REP3(i, m, n) for(int i = m, i##_len=(n);i < i##_len;i++)
#define FORVEC(i, v) for(int i = 0;i < sz(v);i++)


int main(){
    int a,b,k;
    cin>>a>>b>>k;
    if(b-a+1>2*k){
        REP(i,k){
            cout<<a+i<<endl;
        }
        REP(i,k){
            cout<<b-k+i+1<<endl;
        }
    }else{
        REP(i,b-a+1){
            cout<<a+i<<endl;
        }
    }
    return 0;
}
//  [cpp]
#include <bits/stdc++.h>

using namespace std;

int main()
{
	int A,B,K;
	cin>> A>> B>> K;
	for(int i=A;i<min(A+K,B+1);i++)cout<< i<< endl;
	for(int i=max(B-K+1,A+K);i<=B;i++)cout<< i<< endl;

	return 0;
}
//  [cpp]
#include <bits/stdc++.h> 
// #include <atcoder/all>

using namespace std;
// using namespace atcoder;
using ll = long long;
#define rep(i,a,b) for(ll i=(a); i<(b); i++)
#define YES cout << "YES" << endl;
#define NO cout << "NO" << endl;
#define yes cout << "Yes" << endl;
#define no cout << "No" << endl;
#define pai 3.14159265358979323846
ll gcd(ll a, ll b){if (a%b == 0)  return(b);else  return(gcd(b, a%b));}
ll lcm(ll a, ll b){return a * b / gcd(a, b);}

const int mod = 1000000007;
/* map<string,int> */
/* 大文字を小文字に変換 tolower*/
/* 小文字を大文字に変換 toupper*/
/* 辞書順 next_permutation(a.begin(),a.end()) */
void printVec(std::vector<char> &vec) {
  std::cout << "";
  for (auto it = vec.begin(); it != vec.end(); ++it) {
    std::cout << *it << " ";
  }
  std::cout << std::endl;
}


int main() {
    ll a,b;
    cin >> a >> b;
    int k;
    cin >> k;
    rep(i,a,a+k) {
        cout << i << endl;
    }
    rep(i,b-k+1,b+1) {
        cout << i << endl;
    }
}
//  [cpp]
#include<iostream>
using namespace std;
int main()
{

    int a, b, k;
    cin>>a>>b>>k;

    if(2*k>= b-a){
        for(int i=a; i<=b; i++) cout<<i<<endl;
    }
    else{
        for(int i=a; i<=a+k-1; i++) cout<<i<<endl;
        for(int i=b-k+1; i<=b; i++) cout<<i<<endl;
    }


    return 0;
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;

int main()
{
       int a,b,k,n;
       cin>>a>>b>>k;
       n=b-a+1;
       if(n>k){
        for(int i=0;i<k;i++){
            cout<<a<<endl;
            a++;
        }

        for(int j=b-k+1;j<=b;j++){
        if(a-1!=j)
            cout<<j<<endl;

        }
       }
       else {
       for(int i=a;i<=b;i++)
        cout<<i<<endl;
       }
    return 0;
   }
//  [c]
int main(void)
{
    int a,b,k;
    
    scanf("%d%d%d",&a,&b,&k);
    int i=a,j=b-k+1;
    while((i<a+k)&&(i<=b)){
        printf("%d\n",i);
        i++;
    }
    if(i>j) j=i;
    while(j<=b){
        printf("%d\n",j);
        j++;
    }
    return 0;
}
//  [c]
int main(void)
{
    int a,b,k;
    
    scanf("%d%d%d",&a,&b,&k);
    int m=a,n=b-k+1;
    while((m<a+k)&&(m<=b)){
        printf("%d\n",m);
        m++;
    }
    if(m>n) n=m;
    while(n<=b){
        printf("%d\n",n);
        n++;
    }
    return 0;
}
//  [c]
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

typedef long long ll;
typedef int keytype;

int gcd(int a, int b){ return (a % b) ? gcd(b, a % b) : b;}
int lcm(int a, int b){ return (a / gcd(a, b)) * b;}

/* a[0], ..., a[n-1] の数の最大公約数 */
int ngcd(int n, int a[])
{
    int i, d;

    d = a[0];
    for (i = 1; i < n && d != 1; i++)
        d = gcd(a[i], d);
    return d;
}

void quicksort(keytype a[], int first, int last)
{
    int i, j;
    keytype x, t;

    x = a[(first + last) / 2];
    i = first;  j = last;
    for ( ; ; ) {
        while (a[i] < x) i++;
        while (x < a[j]) j--;
        if (i >= j) break;
        t = a[i];  a[i] = a[j];  a[j] = t;
        i++;  j--;
    }
    if (first  < i - 1) quicksort(a, first , i - 1);
    if (j + 1 < last) quicksort(a, j + 1, last);
}

int is_prime(int x){
    if(x <= 1) return 0;
    for(int i = 2; i * i <= x; i++){
        if(x % i == 0) return 0;
    }
    return 1;
}

int is_substr(char s[], char t[], int i){
    int flag = 1;

    if(s[i] == '\0') flag = 0;

    for(int j = 0; j < strlen(t); ++j, ++i){
        if(s[i] != t[j]){
            flag = 0;
            break;
        }
    }
    return flag;
}

// factor list, number of factors, natural number
void factorize(int ftr[], int *num, int n){
    int a = 2, cnt = 0;

    while(n >= a){
        if(n % a == 0){
            n = n / a;
            ftr[cnt++] = a;
        }else{
            a++;
        }
    }
    *num = cnt;
}

//#define N 5
//int p[N + 1];
int nextperm(int p[], int N)  /* 辞書式順序で次の順列 */
{
    int i, j, t;

    i = N - 1;
    p[0] = 0;  /* 番人 */
    while (p[i] >= p[i + 1]) i--;
    if (i == 0) return 0;  /* 完了 */
    j = N;
    while (p[i] >= p[j]) j--;
    t = p[i];  p[i] = p[j];  p[j] = t;
    i++;  j = N;
    while (i < j) {
        t = p[i];  p[i] = p[j];  p[j] = t;  i++;  j--;
    }
    return 1;  /* 未了 */
}

void comb(int size1, int size2, int v[size1][size2]){
  for(int i = 0; i < size1; i++){
    v[i][0] = 1;
    v[i][i] = 1;
  }
  for(int k = 1; k < size1; k++){
    for(int j = 1; j < k; j++){
      v[k][j] = (v[k-1][j-1] + v[k-1][j]);
    }
  }
}

int abs_val(int a, int b){
    if(a > b) return a - b;
    else return b - a;
}

int min(int a, int b){
    if(a > b) return b;
    else return a;
}

const int inf = 1012345678;
int main(){
    int a, b, k;

    scanf("%d %d %d", &a, &b, &k);

    int i = a;
    for(i = a; i < a + k && i <= b; ++i){
        printf("%d\n", i);
    }
    if(i < b - k){
        for(i = (b - k + 1); i <= b; ++i){
            printf("%d\n", i);
        }
    }else{
        for(i = a + k; i <= b; ++i){
            printf("%d\n", i);
        }
    }


    return 0;
}
//  [c]
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

typedef long long ll;
typedef int keytype;

int gcd(int a, int b){ return (a % b) ? gcd(b, a % b) : b;}
int lcm(int a, int b){ return (a / gcd(a, b)) * b;}

/* a[0], ..., a[n-1] の数の最大公約数 */
int ngcd(int n, int a[])
{
    int i, d;

    d = a[0];
    for (i = 1; i < n && d != 1; i++)
        d = gcd(a[i], d);
    return d;
}

void quicksort(keytype a[], int first, int last)
{
    int i, j;
    keytype x, t;

    x = a[(first + last) / 2];
    i = first;  j = last;
    for ( ; ; ) {
        while (a[i] < x) i++;
        while (x < a[j]) j--;
        if (i >= j) break;
        t = a[i];  a[i] = a[j];  a[j] = t;
        i++;  j--;
    }
    if (first  < i - 1) quicksort(a, first , i - 1);
    if (j + 1 < last) quicksort(a, j + 1, last);
}

int is_prime(int x){
    if(x <= 1) return 0;
    for(int i = 2; i * i <= x; i++){
        if(x % i == 0) return 0;
    }
    return 1;
}

int is_substr(char s[], char t[], int i){
    int flag = 1;

    if(s[i] == '\0') flag = 0;

    for(int j = 0; j < strlen(t); ++j, ++i){
        if(s[i] != t[j]){
            flag = 0;
            break;
        }
    }
    return flag;
}

// factor list, number of factors, natural number
void factorize(int ftr[], int *num, int n){
    int a = 2, cnt = 0;

    while(n >= a){
        if(n % a == 0){
            n = n / a;
            ftr[cnt++] = a;
        }else{
            a++;
        }
    }
    *num = cnt;
}

//#define N 5
//int p[N + 1];
int nextperm(int p[], int N)  /* 辞書式順序で次の順列 */
{
    int i, j, t;

    i = N - 1;
    p[0] = 0;  /* 番人 */
    while (p[i] >= p[i + 1]) i--;
    if (i == 0) return 0;  /* 完了 */
    j = N;
    while (p[i] >= p[j]) j--;
    t = p[i];  p[i] = p[j];  p[j] = t;
    i++;  j = N;
    while (i < j) {
        t = p[i];  p[i] = p[j];  p[j] = t;  i++;  j--;
    }
    return 1;  /* 未了 */
}

void comb(int size1, int size2, int v[size1][size2]){
  for(int i = 0; i < size1; i++){
    v[i][0] = 1;
    v[i][i] = 1;
  }
  for(int k = 1; k < size1; k++){
    for(int j = 1; j < k; j++){
      v[k][j] = (v[k-1][j-1] + v[k-1][j]);
    }
  }
}

int abs_val(int a, int b){
    if(a > b) return a - b;
    else return b - a;
}

int min(int a, int b){
    if(a > b) return b;
    else return a;
}

const int inf = 1012345678;
int main(){
    int a, b, k;

    scanf("%d %d %d", &a, &b, &k);

    int i = a;
    for(i = a; i < a + k && i <= b; ++i){
        printf("%d\n", i);
    }
    if(i < b - k){
        for(i = (b - k); i < b; ++i){
            printf("%d\n", i + 1);
        }
    }else{
        for(i = a + k; i <= b; ++i){
            printf("%d\n", i);
        }
    }


    return 0;
}
//  [c]
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

typedef long long ll;
typedef int keytype;

int gcd(int a, int b){ return (a % b) ? gcd(b, a % b) : b;}
int lcm(int a, int b){ return (a / gcd(a, b)) * b;}

/* a[0], ..., a[n-1] の数の最大公約数 */
int ngcd(int n, int a[])
{
    int i, d;

    d = a[0];
    for (i = 1; i < n && d != 1; i++)
        d = gcd(a[i], d);
    return d;
}

void quicksort(keytype a[], int first, int last)
{
    int i, j;
    keytype x, t;

    x = a[(first + last) / 2];
    i = first;  j = last;
    for ( ; ; ) {
        while (a[i] < x) i++;
        while (x < a[j]) j--;
        if (i >= j) break;
        t = a[i];  a[i] = a[j];  a[j] = t;
        i++;  j--;
    }
    if (first  < i - 1) quicksort(a, first , i - 1);
    if (j + 1 < last) quicksort(a, j + 1, last);
}

int is_prime(int x){
    if(x <= 1) return 0;
    for(int i = 2; i * i <= x; i++){
        if(x % i == 0) return 0;
    }
    return 1;
}

int is_substr(char s[], char t[], int i){
    int flag = 1;

    if(s[i] == '\0') flag = 0;

    for(int j = 0; j < strlen(t); ++j, ++i){
        if(s[i] != t[j]){
            flag = 0;
            break;
        }
    }
    return flag;
}

// factor list, number of factors, natural number
void factorize(int ftr[], int *num, int n){
    int a = 2, cnt = 0;

    while(n >= a){
        if(n % a == 0){
            n = n / a;
            ftr[cnt++] = a;
        }else{
            a++;
        }
    }
    *num = cnt;
}

//#define N 5
//int p[N + 1];
int nextperm(int p[], int N)  /* 辞書式順序で次の順列 */
{
    int i, j, t;

    i = N - 1;
    p[0] = 0;  /* 番人 */
    while (p[i] >= p[i + 1]) i--;
    if (i == 0) return 0;  /* 完了 */
    j = N;
    while (p[i] >= p[j]) j--;
    t = p[i];  p[i] = p[j];  p[j] = t;
    i++;  j = N;
    while (i < j) {
        t = p[i];  p[i] = p[j];  p[j] = t;  i++;  j--;
    }
    return 1;  /* 未了 */
}

void comb(int size1, int size2, int v[size1][size2]){
  for(int i = 0; i < size1; i++){
    v[i][0] = 1;
    v[i][i] = 1;
  }
  for(int k = 1; k < size1; k++){
    for(int j = 1; j < k; j++){
      v[k][j] = (v[k-1][j-1] + v[k-1][j]);
    }
  }
}

int abs_val(int a, int b){
    if(a > b) return a - b;
    else return b - a;
}

int min(int a, int b){
    if(a > b) return b;
    else return a;
}

const int inf = 1012345678;
int main(){
    int a, b, k;

    scanf("%d %d %d", &a, &b, &k);

    int i = a;
    for(i = a; i < a + k && i <= b; ++i){
        printf("%d\n", i);
    }
    if(i < b - k){
        for(i = (b - k); i < b; ++i){
            printf("%d\n", i + 1);
        }
    }else{
        for(; i <= b; ++i){
            printf("%d\n", i);
        }
    }


    return 0;
}
//  [javascript]
function main(input) {
    var s = input[0].split(" ").map(v=>v-0);
    var a = s[0], b=s[1], k=s[2];
    var ans = [];
    for(var i=a;i<a+k&&i<=b;i++){
        ans.push(i);
    }
    for(var i=b-k+1;i<=b;i++){
        if(i>=a+k)
            ans.push(i);
    }
    
    console.log(ans.join("\n"));
}
main(require('fs').readFileSync('/dev/stdin', 'utf8').trim().split("\n"))
//  [javascript]
"use strict"

const Main= (input)=>{
  const Array=input.split(" ").map((ele)=>{return ele-0})
  const A=Array[0],B=Array[1],K=Array[2]
  
  const resultArray=[]
  for(let i=A;i<A+K&&i<=B;i++){
    resultArray.push(i)
  }
  for(let j=B-K+1;j<=B;j+=1){
    if(j>=A+K)resultArray.push(j)
  }
  const result=resultArray.join("\n")
  console.log(result)
}

Main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
"use strict";
    
const main = arg => {
    arg     = arg.split("\n")[0].split(" ").map(n=>parseInt(n));
    const A = arg[0];
    const B = arg[1];
    const K = arg[2];
    
    let N = [];
    
    for(let i=0; i<K; i++) {
        if((A+i) > B) break;
        N.push(A+i);
    }
    
    for(let i=0; i<K; i++) {
        if((B-i) < A) break;
        N.push(B-i);
    }
    
    let set = new Set(N);
    
    console.log([...set].sort((a,b)=>a-b).join("\n"));
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
"use strict"

const Main= (input)=>{
  const Array=input.split(" ").map((ele)=>{return ele-0})
  const A=Array[0],B=Array[1],K=Array[2]
  
  const resultArray=[]
  for(let i=A;i<A+K&&i<=B;i++){
    resultArray.push(i)
  }
  for(let j=B-K+1;j<=B&&j>=A+K;j+=1){
    resultArray.push(j)
  }
  const result=resultArray.join("\n")
  console.log(result)
}

Main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
"use strict"

const Main= (input)=>{
  const Array=input.split(" ").map((ele)=>{return ele-0})
  const A=Array[0],B=Array[1],K=Array[2]
  
  const resultArray=[]
  for(let i=A;i<A+K&&i<=B;i++){
    resultArray.push(i)
  }
  for(let j=B-K+1;j>=A&&j>=A+K;j+=1){
    resultArray.push(j)
  }
  const result=resultArray.join("\n")
  console.log(result)
}

Main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
"use strict"

const Main= (input)=>{
  const Array=input.split(" ").map((ele)=>{return ele-0})
  const A=Array[0],B=Array[1],K=Array[2]
  
  const resultArray=[]
  for(let i=A;i<A+K&&i<=B;i++){
    resultArray.push(i)
  }
  for(let j=B-K+1;j>=A&&j>=A+K;i+=1){
    resultArray.push(j)
  }
  const result=resultArray.join("\n")
  console.log(result)
}

Main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [go]
package main

import "fmt"

func main() {
	var a, b, k int
	fmt.Scan(&a, &b, &k)

	for i := a; i <= min(b, a+k-1); i++ {
		fmt.Println(i)
	}
	for i := max(b-k+1, a+k); i <= b; i++ {
		fmt.Println(i)
	}
}

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}
//  [go]
package main

import (
	"fmt"
)

func main() {
	var a,b,k int
	fmt.Scan(&a,&b,&k)
	
	for i := a; i <= min(a+k-1, b); i++ {
		fmt.Println(i)
	}
	for i := max(b-(k-1),a+k); i <= b; i++ {
		fmt.Println(i)
	}

}

func min(a,b int) int {
	if a < b {
		return a
	}
	return b
}

func max(a,b int) int {
	if a < b {
		return b
	}
	return a
}
//  [go]
package main

import (
	. "fmt"
    "sort"
)

// func init() { Println("----------------------------------------") }

func main() {
    var a, b, k int
    Scanf("%d %d %d", &a, &b, &k)

    set := make(map[int]struct{})

    for i := 0; i < k; i++ {
        if a + i <= b {
            if _, ok := set[a + i]; !ok {
                set[a + i] = struct{}{}
            }
        }

        if b - i >= a {
            if _, ok := set[a + i]; !ok {
                set[b - i] = struct{}{}
            }
        }
    }

    res := make([]int, 0, 205)
    for num := range set {
        res = append(res, num)
    }
    sort.Sort(sort.IntSlice(res))

    for _, v := range res {
        Println(v)
    }
}
//  [go]
package main

import (
        "fmt"
)

func solution(a, b, k int) []int {

        out := make([]int, 0, b-a)
        for i := a; i <= b; i++ {
                if i < a+k || b-k < i {
                        out = append(out, i)
                }
        }
        return out
}

func main() {
        var a, b, k int
        fmt.Scan(&a, &b, &k)
        for _, n := range solution(a, b, k) {
                fmt.Println(n)
        }
}
//  [go]
package main

import (
	"fmt"
)

func main() {
	var a, b, k int
	fmt.Scan(&a, &b, &k)

	max := a
	for i := a; i < a+k; i++ {
		if i <= b {
			fmt.Println(i)
			max = i
		}
	}

	for i := max; i <= b; i++ {
		if i >= b-k+1 {
			fmt.Println(i)
		}
	}

}
//  [ruby]
a,b,k = gets.split.map(&:to_i)
arr = []
k.times do |i|
  break if a+i > b
  arr << a+i
end
k.times do |i|
  next if b - (k - 1) + i < a
  arr << b - (k-1) + i
end
puts arr.uniq
//  [ruby]
a,b,k = $stdin.gets.chomp.split(' ').map(&:to_i)
# a = a.to_i,b = b.to_i,k = k.to_i #(.map(&:to_i)でいいんだけど…)

num = a.to_i

k.times do
  puts num
  num = num + 1
  if num > b
    exit
  end
end

if num > b-k
  	(b - num + 1).times do
   	puts num
  	num = num + 1
	end 
else
  num = b - k + 1
	k.times do
  	puts num
  	num = num + 1
	end
end
//  [ruby]
a,b,k = gets.split.map(&:to_i)

k -= 1
if a+k > b || a+k >= b-k
  (a..b).each do |i|
    puts i
  end
else
  (a..a+k).each do |i|
    puts i
  end
  (b-k..b).each do |j|
    puts j
  end
end
//  [ruby]
a,b,n=gets.split.map(&:to_i)
puts b-a+1>2*n ? ([*a..a+n-1],[*b-n+1..b]) : [*a..b]
//  [ruby]
a,b,n=gets.split.map(&:to_i)
l=[*a..b]
s=l.size
puts l[0,[n,s].min] | l[-[n,s].min,n]
//  [ruby]
a,b,k = gets.strip.split.map(&:to_i)
s = (a..a+k-1).to_a+(b-k+1..b).to_a
t = s.uniq.sort
puts t
//  [rust]
use std::io;
use std::collections::HashSet;

fn procon_read<T: std::str::FromStr>() ->  Vec<T> {
	let mut buf = String::new();
	io::stdin().read_line(&mut buf).expect("");
	let iter = buf.split_whitespace();
	let mut v: Vec<T> = Vec::new();
	for i in iter {
		v.push(i.parse().ok().unwrap());
	}
	v
}

fn main() {
	let v:Vec<u64> = procon_read();
	let mut set = HashSet::new();
	let mut p:Vec<u64> = Vec::new();
	let a = v[0];
	let b = v[1];
	let k = v[2];
	if k <= b - a + 1 {
		for i in a..(a+k) {
			if set.insert(i) {
				p.push(i);
			}
		}
		for i in (b-k + 1)..(b+1) {
			if set.insert(i) {
				p.push(i);
			}
		}
		for i in p {
			println!("{}", i);
		}
	}else{
		for i in a..(b+1) {
			println!("{}", i);
		}
	}
}
//  [rust]
use std::io::*;
use std::str::FromStr;

pub fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

use std::cmp::{max, min};
use std::collections::HashSet;

fn main() {
    let a: usize = read();
    let b: usize = read();
    let k: usize = read();
    let mut anss: HashSet<usize> = HashSet::new();

    for i in a..min(a + k, b + 1) {
        anss.insert(i);
    }
    for i in (max(a, b + 1 - k)..b + 1).rev() {
        anss.insert(i);
    }

    let mut uniq: Vec<usize> = anss.into_iter().collect();
    uniq.sort();
    for i in uniq {
        println!("{}", i);
    }
}
//  [rust]
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        let mut next = || { iter.next().unwrap() };
        input_inner!{next, $($r)*}
    };
    ($($r:tt)*) => {
        let stdin = std::io::stdin();
        let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));
        let mut next = move || -> String{
            bytes
                .by_ref()
                .map(|r|r.unwrap() as char)
                .skip_while(|c|c.is_whitespace())
                .take_while(|c|!c.is_whitespace())
                .collect()
        };
        input_inner!{next, $($r)*}
    };
}

macro_rules! input_inner {
    ($next:expr) => {};
    ($next:expr, ) => {};

    ($next:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($next, $t);
        input_inner!{$next $($r)*}
    };
}

macro_rules! read_value {
    ($next:expr, ( $($t:tt),* )) => {
        ( $(read_value!($next, $t)),* )
    };

    ($next:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()
    };

    ($next:expr, chars) => {
        read_value!($next, String).chars().collect::<Vec<char>>()
    };

    ($next:expr, usize1) => {
        read_value!($next, usize) - 1
    };

    ($next:expr, $t:ty) => {
        $next().parse::<$t>().expect("Parse error")
    };
}

fn main() {
    input! {
    a: usize,
    b: usize,
    k: usize,
    }
    if b - a + 1 <= 2 * k {
        for i in a..b + 1{
            println!("{}", i)
        }
        return
    }
    for i in 0..k {
        println!("{}", a + i)
    }
    for i in (0..k).rev() {
        println!("{}", b - i)
    }
}
//  [rust]
use proconio::{input, fastout};
use proconio::marker::{Chars};
use proconio::marker::Usize1;
use std::cmp::*;

macro_rules! debug {
      ($($a:expr),*) => {
          eprintln!(concat!($(stringify!($a), " = {:?}, "),*), $($a),*);
    }
}

#[fastout]
fn main() {
    input!{
        a: usize,
        b: usize,
        k: usize,
    }

    for i in a..min(b+1,a+k) {
        println!("{}", i);
    }

    if b<a+k {
        return;
    } else if b>a+2*k {
        for i in b-k+1..b+1 {
            println!("{}", i);
        }
    } else {
        for i in a+k..b+1 {
            println!("{}", i);
        }
    }

}
//  [rust]
#![allow(unused_macros)]
#![allow(dead_code)]
#![allow(unused_imports)]

use itertools::Itertools;
use std::collections::HashSet;
use text_io::*;

const U_INF: usize = 1 << 60;
const I_INF: isize = 1 << 60;

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

    let mut hs = HashSet::new();

    for i in a..(a + k).min(b) {
        hs.insert(i);
    }

    for i in (b.wrapping_sub(k) + 1).max(a)..=b {
        hs.insert(i);
    }

    let hs = hs.iter().sorted().collect_vec();

    for v in hs {
        println!("{}", v);
    }
}
//  [rust]
#![allow(unused_macros)]
#![allow(dead_code)]
#![allow(unused_imports)]

use itertools::Itertools;
use std::collections::HashSet;
use text_io::*;

const U_INF: usize = 1 << 60;
const I_INF: isize = 1 << 60;

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

    let mut hs = HashSet::new();

    for i in a..a + k {
        hs.insert(i);
    }

    for i in b - k + 1..=b {
        hs.insert(i);
    }

    let hs = hs.iter().sorted().collect_vec();

    for v in hs {
        println!("{}", v);
    }
}
//  [swift]
import Foundation

#if swift(>=4.0)
extension String {
    func split(by separator: String) -> [String] {
        return self.components(separatedBy: separator)
    }
    func toArray() -> [String] {
        return self.map{String($0)}
    }
}
func exponentiate(_ lhs: Int, _ rhs: Int) -> Int {
    return (0..<rhs).reduce(1){i,_ in i*lhs}
}
#else
extension String {
    func split(by separator: String) -> [String] {
        return self.componentsSeparatedByString(separator)
    }
    var count: Int {
        return self.characters.count
    }
    func toArray() -> [String] {
        return self.characters.map{String($0)}
    }
    func uppercased() -> String {
        return self.uppercaseString
    }
    func lowercased() -> String {
        return self.lowercaseString
    }
}
//extension Array where Element == String {
//    func joined(separator separator: String) -> String {
//        return self.joinWithSeparator(separator)
//    }
//}
extension Array where Element: Comparable {
    func max() -> Element {
        return self.maxElement()!
    }
    func min() -> Element {
        return self.minElement()!
    }
    func sorted() -> Array {
        return self.sort()
    }
    func reversed() -> Array {
        return self.reverse()
    }
    mutating func sort() {
        self.sortInPlace()
    }
}
extension Array {
    init(repeating: Element, count: Int) {
        self.init(count: count, repeatedValue: repeating)
    }
}
func stride<T: Strideable>(from start: T, to end: T, by stride: T.Stride) -> StrideTo<T> {
    return start.stride(to: end, by: stride)
}
func exponentiate(lhs: Int, _ rhs: Int) -> Int {
    return (0..<rhs).reduce(1){i,_ in i*lhs}
}
#endif
func readInt() -> Int? {
    return Int(readLine()!)
}
func readStringSplit(by separator: String) -> [String] {
    return readLine()!.split(by: separator)
}
func readIntSplit(by separator: String) -> [Int] {
    return readLine()!.split(by: separator).map{Int($0)!}
}

/*************** テストスペース ***************/

//var min, min2, count: Int!
//for i in 1...10 {
//    let x = readInt()!
//    if i == 1 {
//        min = x
//        count = 1
//    } else if x < min {
//        min2 = min
//        min = x
//        count = 1
//    } else if x == min && count == 1 {
//        min2 = x
//        count = 2
//    }
//}
//print(min2)

/*************** メインプログラム ***************/

let input = readIntSplit(by: " ")
let (A, B, K) = (input[0], input[1], input[2])
for i in A...min(A+K-1, B) {
    print(i)
}
let start = min(max(A+K, B-K+1), B+1)
for i in start..<B+1 {
    print(i)
}
//  [swift]
import Foundation
func toTuple<T>(_ args: [T]) -> (T, T, T) { (args[0], args[1], args[2]) }
func readInts() -> [Int] { readLine()!.split(separator: " ").map { Int($0)! } }

let (a, b, k) = toTuple(readInts())
var array: [Int] = []
if (b - a) / 2 >= k {
  array.append(contentsOf: a...a+k-1)
  array.append(contentsOf: b-k+1...b)
} else {
  array.append(contentsOf: a...b)
}
Set(array).sorted().forEach { print($0) }
//  [typescript]
const input=require('fs').readFileSync('/dev/stdin','utf8').split(/[\s]/);const tn=():number=>{const a=input[0];input.shift();return Number(a)};const tnn=(n:number):number[]=>{const a=[];for(let i=0;i<n;i++){a.push(tn())}return a};const ts=():string=>{const a=input[0];input.shift();return String(a)};const tss=(n:number):string[]=>{const a=[];for(let i=0;i<n;i++){a.push(ts())}return a};const tc=():string=>{let a=input[0].split('');const b=a[0];a.shift();if(a.length>0){input[0]=a.join('')}else{input.shift()}return String(b)};const tcc=(n:number):string[]=>{const a=[];for(let i=0;i<n;i++){a.push(tc())}return a};const to=(...arg)=>{console.log(...arg)};const abs=(a)=>{return Math.abs(a)};const min=(...a)=>{return Math.min(...a)};const max=(...a)=>{return Math.max(...a)};const floor=(a)=>{return Math.floor(a)};const asc=(ar:number[])=>{return ar.sort((a,b)=>{return a-b})};const desc=(ar:number[])=>{return ar.sort((a,b)=>{return b-a})};const sw=(a,arr:any[],op:'=='|'>='|'>'|'<='|'<'='==')=>{for(let i=0;i<arr.length-1;i+=2){if(eval(a+op+arr[i])){return arr[i+1];}}return arr[arr.length-1]};const near=(n:number,arr:number[]):number=>{let ne=arr[0],ni=0;for(let i=1;i<arr.length;i++){if(Math.abs(n-ne)>Math.abs(n-arr[i])){ne=arr[i];ni=i}}return ni};
const main=()=>{
  let [a,b,k]=tnn(3)
  let x=[]
  for(let i=0;i<k;i++){
    if(a+i>b-i){
      break
    }
    if(a+i===b-i){
      x.push(a+i)
      break
    }else {
      x.push(a+i)
      x.push(b-i)
    }
  }
  to(...asc(x))
}
main()
//  [typescript]
function Main(input) {
    input = input.split(' ');
    const A = Number(input[0]);
    const B = Number(input[1]);
    const K = Number(input[2]);

    for (let i = A; i < A + K && i <= B; i++) {
        console.log(i);
    }

    for (let i = B - K + 1; i <= B && i > A; i++) {
        if (i < A + K) continue;
        console.log(i);
    }
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [typescript]
import { readFileSync } from "fs";

const read = () =>
  readFileSync(0, "utf8")
    .split("\n")
    .map((line) => line.split(" "));

const range = (start: number, stop: number) =>
  [...Array(stop - start + 1)].map((_, i) => start + i);

const main = (input: string[][]) => {
  const [A, B, K] = input[0].map(Number);

  if (A + K - 1 >= B - K + 1) {
    return range(A, B).join("\n");
  }

  return [...range(A, A + K - 1), ...range(B - K + 1, B)].join("\n");
};

console.log(main(read()));
//  [typescript]
function Main(input: string): void {
    const parseInputs = parseInput(input);
    const witdhinRangeValues = witdhinRangeValue(parseInputs);
    isPrint(witdhinRangeValues);
}
const parseInput = (input: string) => {
    const lines = input.split(" ").map(x => parseInt(x));
    const parseInputs = {
    aboveValue: lines[0],
    belowValue: lines[1],
    threshold: lines[2],
    }
    return(parseInputs);
}
const witdhinRangeValue = (parseInputs: Input, checkValue?: number, witdhinRangeValues?: number[]) => {
    //初期値がない場合、checkValueにaboveValueを代入
    if (!checkValue) checkValue = parseInputs.aboveValue;
    let resultValue: number[];
    if(witdhinRangeValueCheck(parseInputs,checkValue)){        
        resultValue = witdhinRangeValues.concat(checkValue);
    }
    checkValue++;
    //belowValue以上の場合、処理を終了する
    if(checkValue > parseInputs.belowValue) return witdhinRangeValues;
    //再起関数
    return witdhinRangeValue(parseInputs,checkValue,resultValue);
}
//条件を満たしているか確認する関数。閾値に入っていればtrueを返し、入っていなければfalseを返す
const witdhinRangeValueCheck = ({aboveValue,belowValue,threshold}: Input,checkValue: number) => {
    if(aboveValue<= checkValue && checkValue < aboveValue + threshold){
        return true;

    }
    else if(belowValue-threshold < checkValue && checkValue <= belowValue){
        return true;
    }
    else false;
} 
const isPrint = (witdhinRangeValues: number[]) => {
    witdhinRangeValues.map(x => console.log(x));
}
interface Input {
    aboveValue: number;
    belowValue: number;
    threshold: number;
}
const input =
"3 8 2" ;
Main(input);
//  [typescript]
function Main(input: string): void {
    const parseInputs = parseInput(input);
    const witdhinRangeValues = witdhinRangeValue(parseInputs);
    isPrint(witdhinRangeValues);
}
const parseInput = (input: string) => {
    const lines = input.split(" ").map(x => parseInt(x));
    const parseInputs = {
    aboveValue: lines[0],
    belowValue: lines[1],
    threshold: lines[2],
    }
    return(parseInputs);
}
const witdhinRangeValue = (parseInputs: Input, checkValue?: number, witdhinRangeValues?: number[]) => {
    //初期値がない場合、checkValueにaboveValueを代入
    if (!checkValue) checkValue = parseInputs.aboveValue;
    if(witdhinRangeValueCheck(parseInputs,checkValue)){        
        witdhinRangeValues.concat(checkValue);
    }
    checkValue++;
    //belowValue以上の場合、処理を終了する
    if(checkValue > parseInputs.belowValue) return witdhinRangeValues;
    //再起関数
    return witdhinRangeValue(parseInputs);
}
//条件を満たしているか確認する関数。閾値に入っていればtrueを返し、入っていなければfalseを返す
const witdhinRangeValueCheck = ({aboveValue,belowValue,threshold}: Input,checkValue: number) => {
    if(aboveValue<= checkValue && checkValue < aboveValue + threshold){
        return true;

    }
    else if(belowValue-threshold < checkValue && checkValue <= belowValue){
        return true;
    }
    else false;
} 
const isPrint = (witdhinRangeValues: number[]) => {
    witdhinRangeValues.map(x => console.log(x));
}
interface Input {
    aboveValue: number;
    belowValue: number;
    threshold: number;
}
const input =
"3 8 2" ;
Main(input);
//  [typescript]
function Main(input: string): void {
    const parseInputs = parseInput(input);
    witdhinRangeValue(parseInputs);
}
var parseInput = (input: string) => {
    const lines = input.split(" ").map(x => parseInt(x));
    const parseInputs = {
    aboveValue: lines[0],
    belowValue: lines[1],
    threshold: lines[2],
    }
    return(parseInputs);
}
var witdhinRangeValue = (parseInputs) => {
    //初期値がない場合、checkValueにaboveValueを代入
    if (!parseInputs.checkValue) parseInputs.checkValue = parseInputs.aboveValue;

    if(witdhinRangeValueCheck(parseInputs)){
        console.log(parseInputs.checkValue);
    }
    parseInputs.checkValue++;
    //belowValue以上の場合、処理を終了する
    if(parseInputs.checkValue > parseInputs.belowValue){
        return;
    }
    //再起関数
    return witdhinRangeValue(parseInputs);
}

//条件を満たしているか確認する関数。閾値に入っていればtrueを返し、入っていなければfalseを返す
var witdhinRangeValueCheck = ({aboveValue,belowValue,threshold,checkValue}) => {
    if(aboveValue<= checkValue && checkValue < aboveValue + threshold){
        return true;

    }
    else if(belowValue-threshold < checkValue && checkValue <= belowValue){
        return true;
    }
    else false;
} 
interface inputObj {
    checkValue?: number;
    aboveValue: number;
    belowValue: number;
    threshold: number;
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [python]
S=input()

for i in range(3):
    if S[i]==S[i+1]:
        ans='Bad'
        break
    else :
        ans='Good'
print(ans)
//  [python]
S = input()
A = "Good"
for i in range (3):
    if S[i] == S[i + 1]:
        A = "Bad"
print(A)
//  [python]
S  = list(input())
flag = False
for i in range(1,len(S)):
    if S[i-1] == S[i]:
        flag = True
        
if flag:
    print('Bad')
else:
    print('Good')
//  [python]
num=input()
c=False
for i in range(1,len(num)+1):
  if num[i]==num[i-1]:
    c=True
    
if c==True:
  print("Bad")
else:
  print("Good")
//  [python]
import math

A, B, C, D = map(int, input().split(' '))

num_C_baisu = B//C - (A-1)//C #(math.ceil(A/C) - 1)

num_D_baisu = B//D - (A-1)//D #(math.ceil(A/D) - 1)

CD = int(C*D/math.gcd(C,D))

num_CD_baisu = B//CD - (A-1)//CD #(math.ceil(A/CD) - 1)

baisu_num = num_C_baisu + num_D_baisu - num_CD_baisu

print(B-A+1-baisu_num)
//  [python]
S = input()
ans = "Good"
for i in range(2):
  if S[i] == S[i+1]:
    ans = "Bad"
    break
print(ans)
//  [java]
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Main {
    public static void main(String args[]) throws Exception{
        BufferedReader stdR = new BufferedReader(new InputStreamReader(System.in));
        String s = stdR.readLine();
        boolean conse = false;
        char before = s.charAt(0);
        for(int i = 1 ; i < s.length(); i++) {
            if(before == s.charAt(i))conse = true;
            before = s.charAt(i);
        }
        if(conse) {
            System.out.println("Bad");
        }else {
            System.out.println("Good");
        }
    }
}
//  [java]
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Main {

    public static void main(String[] args) throws Exception {
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))) {
            char[] chars = reader.readLine().toCharArray();

            if (chars[0] == chars[1] || chars[1] == chars[2] || chars[2] == chars[3]) {
                System.out.println("Bad");
            } else {
                System.out.println("Good");
            }
        }
    }

}
//  [java]
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class Main {
  public static void main(String[] args) throws IOException {
    BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    String str = in.readLine();
    char[] c = str.toCharArray();
    System.out.println(c[0]==c[1]||c[1]==c[2]||c[2]==c[3]?"Bad":"Good");
  }
}
//  [java]
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        try (Scanner in = new Scanner(System.in)) {
            String S = in.next();
            for (int i = 1; i < S.length(); i++) {
                if (S.charAt(i - 1) == S.charAt(i)) {
                    System.out.println("No");
                    return;
                }
            }
            System.out.println("Yes");
        }
    }
}
//  [java]
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;

public class Main {

	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		String str[] = br.readLine().split("");

		int a = Integer.parseInt(str[0]);
		int b = Integer.parseInt(str[1]);
		int c = Integer.parseInt(str[2]);
		int d = Integer.parseInt(str[3]);

		if (a == b || b == c || c == d) {
			System.out.println("Bad");
		} else {
			System.out.println("Yes");
		}
	}
}
//  [java]
var str=readLine()!

for num in 0...3{
  let a=str.index(str.startIndex,offsetBy:num)
  let b=str.index(str.startIndex,offsetBy:num+1)

  if str[a]==str[b] {
    print("Bad")
    break;
  }
  else if num==3 {
    print("Good")
  }
}
//  [cpp]
#include<stdio.h>
#include<string.h>
int main()
{
    char ara[10];
    int i,flag=0;
    scanf("%s",ara);
    for(i=0;i<strlen(ara);i++)
    {
        if(ara[i]==ara[i+1])
            flag=1;
    }
    if(flag==1)
        printf("Bad\n");
    else
        printf("Good\n");
    return 0;
}