use std::vec::Vec;
use std::cmp::*;
use std::collections::BinaryHeap;
use std::cmp::Ordering;

pub trait LexicalPermutation {
    /// Return `true` if the slice was permuted, `false` if it is already
    /// at the last ordered permutation.
    fn next_permutation(&mut self) -> bool;
    /// Return `true` if the slice was permuted, `false` if it is already
    /// at the first ordered permutation.
    fn prev_permutation(&mut self) -> bool;
}

impl<T> LexicalPermutation for [T] where T: Ord {
    /// Original author in Rust: Thomas Backman <serenity@exscape.org>
    fn next_permutation(&mut self) -> bool {
        // These cases only have 1 permutation each, so we can't do anything.
        if self.len() < 2 { return false; }

        // Step 1: Identify the longest, rightmost weakly decreasing part of the vector
        let mut i = self.len() - 1;
        while i > 0 && self[i-1] >= self[i] {
            i -= 1;
        }

        // If that is the entire vector, this is the last-ordered permutation.
        if i == 0 {
            return false;
        }

        // Step 2: Find the rightmost element larger than the pivot (i-1)
        let mut j = self.len() - 1;
        while j >= i && self[j] <= self[i-1]  {
            j -= 1;
        }

        // Step 3: Swap that element with the pivot
        self.swap(j, i-1);

        // Step 4: Reverse the (previously) weakly decreasing part
        self[i..].reverse();

        true
    }

    fn prev_permutation(&mut self) -> bool {
        // These cases only have 1 permutation each, so we can't do anything.
        if self.len() < 2 { return false; }

        // Step 1: Identify the longest, rightmost weakly increasing part of the vector
        let mut i = self.len() - 1;
        while i > 0 && self[i-1] <= self[i] {
            i -= 1;
        }

        // If that is the entire vector, this is the first-ordered permutation.
        if i == 0 {
            return false;
        }

        // Step 2: Reverse the weakly increasing part
        self[i..].reverse();

        // Step 3: Find the rightmost element equal to or bigger than the pivot (i-1)
        let mut j = self.len() - 1;
        while j >= i && self[j-1] < self[i-1]  {
            j -= 1;
        }

        // Step 4: Swap that element with the pivot
        self.swap(i-1, j);

        true
    }

}

fn warshal_floyd(n: usize, v: &Vec<(usize, usize, usize)>, direct: bool) -> Vec<Vec<usize>> {
  let mut dist = vec![vec![std::usize::MAX/3; n]; n];
  // init
  for &(x, y, c) in v {
    dist[x][y] = c;
    if !direct {
      dist[y][x] = c;
    }
  }

  for i in 0..n {
    for j in 0..n {
      for k in 0..n {
        if dist[i][j] > dist[i][k] + dist[k][j] {
          dist[i][j] = dist[i][k] + dist[k][j];
        }
      }
    }
  }
  dist
}

fn read<T: std::str::FromStr>() -> T {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim().parse().ok().unwrap()
}

fn read_vec<T: std::str::FromStr>() -> Vec<T> {
    read::<String>().split_whitespace().map(|e| e.parse().ok().unwrap()).collect()
}

fn main() {
  let (n, m, r) = {
    let v: Vec<usize> = read_vec();
    (v[0], v[1], v[2])
  };

  let mut v: Vec<usize> = read_vec::<usize>().iter().map(|&x| x - 1).collect();
  let mut t: Vec<(usize, usize, usize)> = Vec::new();
  for _ in 0..m {
    let s: Vec<usize> = read_vec();
    t.push((s[0] - 1, s[1] - 1, s[2]));
  }

  v.sort();
  // 各頂点の経路探索
  let dist = warshal_floyd(n, &t, false);

  let mut res = std::usize::MAX;

  while {
    let mut tmp = 0;
    for i in 1..r {
      tmp += dist[v[i-1]][v[i]];
    }
    res = min(res, tmp);
    v.next_permutation()
  } {}

  println!("{}", res);

}


let N=Int(readLine()!)!;print(N/10<9&&N%10<9 ?"No":"Yes")


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")
}


let N=Int(readLine()!)!;print(N/10<9||N%10<9 ?"No":"Yes")


"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);
}


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();
}


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()


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'));


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)


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)


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)


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)


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)


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()


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");
		}
	}
}


import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.NoSuchElementException;

public class Main {
	static FastScanner sc = new FastScanner();
	static PrintWriter out = new PrintWriter(System.out);

	public static void main(String[] args) {
		int a = sc.nextInt();
		int b = sc.nextInt();
		int k = sc.nextInt();

		int min = a+k-1;
		int max = b-k+1;

		if (max<=min){
			for (int i=a; i<=b; i++)
				out.println(i);
		}
		else {
			for (int i=a; i<=min; i++)
				out.println(i);
			for (int i=max; i<=b; i++)
				out.println(i);
		}

		out.flush();
	}

		static class FastScanner {
		    private final InputStream in = System.in;
		    private final byte[] buffer = new byte[1024];
		    private int ptr = 0;
		    private int buflen = 0;

		    private boolean hasNextByte() {
		      if (ptr < buflen) {
		        return true;
		      } else {
		        ptr = 0;
		        try {
		          buflen = in.read(buffer);
		        } catch (IOException e) {
		          e.printStackTrace();
		        }
		        if (buflen <= 0) {
		          return false;
		        }
		      }
		      return true;
		    }

		    private int readByte() {
		      if (hasNextByte()) return buffer[ptr++];
		      else return -1;
		    }

		    private static boolean isPrintableChar(int c) {
		      return 33 <= c && c <= 126;
		    }

		    private void skipUnprintable() {
		      while (hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++;
		    }

		    public boolean hasNext() {
		      skipUnprintable();
		      return hasNextByte();
		    }

		    public String next() {
		      if (!hasNext()) throw new NoSuchElementException();
		      StringBuilder sb = new StringBuilder();
		      int b = readByte();
		      while (isPrintableChar(b)) {
		        sb.appendCodePoint(b);
		        b = readByte();
		      }
		      return sb.toString();
		    }

		    public long nextLong() {
		      if (!hasNext()) throw new NoSuchElementException();
		      long n = 0;
		      boolean minus = false;
		      int b = readByte();
		      if (b == '-') {
		        minus = true;
		        b = readByte();
		      }
		      if (b < '0' || '9' < b) {
		        throw new NumberFormatException();
		      }
		      while (true) {
		        if ('0' <= b && b <= '9') {
		          n *= 10;
		          n += b - '0';
		        } else if (b == -1 || !isPrintableChar(b)) {
		          return minus ? -n : n;
		        } else {
		          throw new NumberFormatException();
		        }
		        b = readByte();
		      }
		    }

		    public int nextInt() {
		      return (int) nextLong();
		    }

		    public int[] nextIntArray(int N, boolean oneBased) {
		      if (oneBased) {
		        int[] array = new int[N + 1];
		        for (int i = 1; i <= N; i++) {
		          array[i] = sc.nextInt();
		        }
		        return array;
		      } else {
		        int[] array = new int[N];
		        for (int i = 0; i < N; i++) {
		          array[i] = sc.nextInt();
		        }
		        return array;
		      }
		    }

		    public long[] nextLongArray(int N, boolean oneBased) {
		      if (oneBased) {
		        long[] array = new long[N + 1];
		        for (int i = 1; i <= N; i++) {
		          array[i] = sc.nextLong();
		        }
		        return array;
		      } else {
		        long[] array = new long[N];
		        for (int i = 0; i < N; i++) {
		          array[i] = sc.nextLong();
		        }
		        return array;
		      }
		    }
		  }

		}


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;
		}

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

}


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);
            }
        }
    }
}


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);
            }
        }
    }
}


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));
            }
        }
	}
}


#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;
}


#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;
}


#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;
}


#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;
    }
}


#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;
}


#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;
   }


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;
}


#pragma warning(disable:4996)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <float.h>

#pragma region 定義
#define i_cin(X) scanf("%d", &X)
#define i_cin2(X,Y) scanf("%d %d",&X,&Y)
#define i_cin4(X,Y,Z,W) scanf("%d %d %d %d",&X,&Y,&Z,&W)
#define i_cin3(X,Y,Z) scanf("%d %d %d",&X,&Y,&Z)
#define l_cin(X) scanf("%ld",&X)
#define f_cin(X) scanf("%f",&X)
#define l_cin2(X,Y) scanf("%ld %ld",&X,&Y)
#define s_cin(X) scanf("%s",&X)
#define ll_cin(X) scanf("%lld", &X)
#define ull_cin(X) scanf("%llu", &X)
#define lf_cin(X) scanf("%lf", &X)

#define  i_cout(X) printf("%d\n",X)
#define  f_cout(X) printf("%g\n",X)
#define  i_cout2(X,Y) printf("%d %d\n",X,Y)
#define  l_cout(X) printf("%ld\n",X)
#define  s_cout(X) printf("%s\n",X)

#define  ll_cout(X) printf("%lld\n",X)
#define  ull_cout(X) printf("%llu\n",X)

typedef long long  ll;
typedef unsigned long long  ull;

#define rept(x, s, n) for (int x = s; x < n; x++)

#define S_RTN(S)  s_cout(S);return 0

#define _itoa(A,N) sprintf(A, "%d", N);

int i_cins(int n, int* A);
int l_cins2(int n, long* A, long* B);
int s_dsort(const void* a, const void* b);
int s_asort(const void* a, const void* b);

int  _gcd(int a, int b);
int  _swp(int* a, int* b);
int _cknum(char* a, int n);
int _atoi(char* s, int len);

int s_asorts(const void* a, const void* b);

//昇順
int s_asorts(const void* a, const void* b) {
	return(strcmp((char*)a, (char*)b));
}
int s_dsort(const void* a, const void* b) {
	return(*(int*)b - *(int*)a);
}
int s_asort(const void* a, const void* b) {
	return(*(int*)a - *(int*)b);
}
int l_cins2(int n, long* a, long* b) {
	int i;
	rept(i, 0, n) {
		l_cin2(*(a + i), *(b + i));
	}
	return 0;
}
int i_cins(int n, int* a) {
	int i;
	for (i = 0; i < n; i++) {
		i_cin(*(a + i));
	}

	return 0;
}
int _gcd(int a, int b) {
	int r, tmp;
	if (a < b) { tmp = a; a = b; b = tmp; }
	r = a % b;
	while (r) {
		if (!r) break;
		a = b; b = r;
		r = a % b;
	}
	return(b);
}

long _max(long a, long b) {
	return a > b ? a : b;
}
long _min(long a, long b) {
	return a < b ? a : b;
}
int _swp(int* a, int* b)
{
	int tmp;
	tmp = *b; *b = *a; *a = tmp;
	return 0;
}

int _cknum(char* a, int n) {
	int i;
	char t = '0';

	for (i = 0; i < n; i++) {
		if (a[i] < '0' || a[i]>'9') return 1;
	}
	return 0;
}

int _atoi(char* s, int len) {
	char tmp[20];
	memcpy(tmp, s, len);
	tmp[len] = 0x00;
	return (atoi(tmp));
}
#pragma endregion

static int c[51];

 int main(void)
{
	int  a,b,k,i=0;
	int  st, ed, st2=0, ed2=0;

	i_cin3(a,b,k);

	if ((b-a) <= ((k-1) * 2)) {
		st=a;ed=b;
	}
	else {
		st=a;ed=a+k-1;
		st2=b-k+1;ed2=b;
	}

	for (i = st; i<=ed; i++) {
		i_cout(i);
	}
	//printf(":");
	if (!st2) return 0;
	//printf(":\n");
	for (i = st2; i <= ed2; i++) {
		i_cout(i);
	}
 return 0;

}

// 93-C
//int main(void) {
//	int a, b, c;
//	int i,x, y, z, m, cnt = 0;
//
//	i_cin3(a, b, c);
//
//	x=abs(a-b);
//	y=abs(a-c);
//	z=abs(b-c);
//
//	m = _max(_max(x,y), z);
//	cnt = m / 2 + 1;
//	i_cout(cnt);
//	return 0;
//}

//#define _N 1000000000

//int main(void)
//{
//
//	int  n,i;
//	ull   tmp=1;
//
//	i_cin(n);
//
//	for (i = 1; i <= n; i++) {
//		if (!(tmp % ((ull)_N + 7)))
//			tmp = 1;
//		tmp *= (ull)i;
//	}
//	tmp %= ((ull)_N + 7);
//
//	ull_cout(tmp);
//	return 0;
//}


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;
}


#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;
}


#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;
}


#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;
}


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"))


"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'));


"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'));


"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'));


"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'));


"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'));


package main

import (
	"bufio"
	"bytes"
	"fmt"
	"io"
	"os"
	"reflect"
	"strconv"
	"unsafe"
)

var DEBUG = true

func main() {
	defer Flush()
	A := readi()
	B := readi()
	K := readi()

	m := make(map[int]bool)

	for i := 0; i < K; i++ {
		v := A + i
		if B < v {
			break
		}
		println(v)
		m[v] = true
	}

	for i := 0; i < K; i++ {
		v := B - K + 1 + i
		if v < A {
			continue
		}
		if m[v] {
			continue
		}
		println(v)
	}
}

// =============================================================================

// Copyright 2017 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// these functions are derived from sort in Go source.
// name of functions are changed

// The function panics if the provided interface is not a slice.
func Reverse(slice interface{}) {
	rv := reflect.ValueOf(slice)
	swap := _reverse_Swapper(slice)
	length := rv.Len()
	for i, j := 0, length-1; i < j; i, j = i+1, j-1 {
		swap(i, j)
	}
}

func _reverse_Swapper(slice interface{}) func(i, j int) {
	v := reflect.ValueOf(slice)
	vdata := v.Pointer()
	vlen := v.Len()
	vcap := v.Cap()

	sz := int(v.Type().Elem().Size())

	// for typical small elements
	switch sz {
	case 24: // for slice
		var s [][3]int64
		h := (*reflect.SliceHeader)(unsafe.Pointer(&s))
		h.Data = vdata
		h.Len = vlen
		h.Cap = vcap
		return func(i, j int) { s[i], s[j] = s[j], s[i] }
	case 16: // for string
		var s [][2]int64
		h := (*reflect.SliceHeader)(unsafe.Pointer(&s))
		h.Data = vdata
		h.Len = vlen
		h.Cap = vcap
		return func(i, j int) { s[i], s[j] = s[j], s[i] }
	case 8:
		var s []int64
		h := (*reflect.SliceHeader)(unsafe.Pointer(&s))
		h.Data = vdata
		h.Len = vlen
		h.Cap = vcap
		return func(i, j int) { s[i], s[j] = s[j], s[i] }
	case 4:
		var s []int32
		h := (*reflect.SliceHeader)(unsafe.Pointer(&s))
		h.Data = vdata
		h.Len = vlen
		h.Cap = vcap
		return func(i, j int) { s[i], s[j] = s[j], s[i] }
	case 2:
		var s []int16
		h := (*reflect.SliceHeader)(unsafe.Pointer(&s))
		h.Data = vdata
		h.Len = vlen
		h.Cap = vcap
		return func(i, j int) { s[i], s[j] = s[j], s[i] }
	case 1:
		var s []int8
		h := (*reflect.SliceHeader)(unsafe.Pointer(&s))
		h.Data = vdata
		h.Len = vlen
		h.Cap = vcap
		return func(i, j int) { s[i], s[j] = s[j], s[i] }
	}

	// for large elements
	if sz%16 == 0 {
		m := sz / 16
		var s [][2]int64
		h := (*reflect.SliceHeader)(unsafe.Pointer(&s))
		h.Data = vdata
		h.Len = vlen * m
		h.Cap = vcap * m
		return func(i, j int) {
			for k := 0; k < m; k++ {
				ri := i*m + k
				rj := j*m + k
				s[ri], s[rj] = s[rj], s[ri]
			}
		}
	}
	if sz%8 == 0 {
		m := sz / 8
		var s []int64
		h := (*reflect.SliceHeader)(unsafe.Pointer(&s))
		h.Data = vdata
		h.Len = vlen * m
		h.Cap = vcap * m
		return func(i, j int) {
			for k := 0; k < m; k++ {
				ri := i*m + k
				rj := j*m + k
				s[ri], s[rj] = s[rj], s[ri]
			}
		}
	}
	if sz%4 == 0 {
		m := sz / 4
		var s []int32
		h := (*reflect.SliceHeader)(unsafe.Pointer(&s))
		h.Data = vdata
		h.Len = vlen * m
		h.Cap = vcap * m
		return func(i, j int) {
			for k := 0; k < m; k++ {
				ri := i*m + k
				rj := j*m + k
				s[ri], s[rj] = s[rj], s[ri]
			}
		}
	}
	if sz%2 == 0 {
		m := sz / 2
		var s []int16
		h := (*reflect.SliceHeader)(unsafe.Pointer(&s))
		h.Data = vdata
		h.Len = vlen * m
		h.Cap = vcap * m
		return func(i, j int) {
			for k := 0; k < m; k++ {
				ri := i*m + k
				rj := j*m + k
				s[ri], s[rj] = s[rj], s[ri]
			}
		}
	} else {
		m := sz
		var s []int8
		h := (*reflect.SliceHeader)(unsafe.Pointer(&s))
		h.Data = vdata
		h.Len = vlen * m
		h.Cap = vcap * m
		return func(i, j int) {
			for k := 0; k < m; k++ {
				ri := i*m + k
				rj := j*m + k
				s[ri], s[rj] = s[rj], s[ri]
			}
		}
	}
}

// =============================================================================
// -----------------------------------------------------------------------------

// IO helper functions

// Returns next token from input.  It must be initialized by SetInput()
// before the first call.
var nextToken func() ([]byte, error)
var nextLine func() ([]byte, error)

// Holds a buffer for output.  It must be initialized by SetOutput().
// All IO fucntions (read*() and [e]print*()) should write to OutputWriter
// instead of this.
var OutputBuffer *bufio.Writer

// Holds an io.Writer.  It must be initialized by SetOutput()
var OutputWriter io.Writer

// Set IO functions for interactive input/output.
func SetInteractive(w io.Writer, r io.Reader) {
	SetUnbefferedInput(r)
	OutputBuffer = nil
	OutputWriter = w
}

// Setup OutputBuffer and OutputWriter.
func SetOutput(w io.Writer) {
	OutputBuffer = bufio.NewWriter(w)
	OutputWriter = OutputBuffer
}

// Flushes OutputBuffer
func Flush() {
	if OutputBuffer != nil {
		OutputBuffer.Flush()
	}
}

// Returns true if c is a white space
func IsSpace(c byte) bool {
	switch c {
	case '\t', '\n', '\v', '\f', '\r', ' ':
		return true
	}
	return false
}

func IsNewLine(c byte) bool {
	switch c {
	case '\n', '\r':
		return true
	}
	return false
}

// Setup nextToken with input buffer.
func SetInput(r io.Reader) {
	buf := new(bytes.Buffer)
	var b []byte

	var i int
	rest := func() ([]byte, error) {
		for i < len(b) && IsSpace(b[i]) {
			i++
		}
		if i == len(b) {
			return nil, io.ErrUnexpectedEOF
		}
		j := i
		for i < len(b) && !IsSpace(b[i]) {
			i++
		}
		return b[j:i], nil
	}
	initial := func() ([]byte, error) {
		io.Copy(buf, r)
		b = buf.Bytes()
		nextToken = rest
		return rest()
	}
	nextToken = initial

	restLn := func() ([]byte, error) {
		for i < len(b) && IsNewLine(b[i]) {
			i++
		}
		if i == len(b) {
			return nil, io.ErrUnexpectedEOF
		}
		j := i
		for i < len(b) && !IsNewLine(b[i]) {
			i++
		}
		return b[j:i], nil
	}

	initialLn := func() ([]byte, error) {
		io.Copy(buf, r)
		b = buf.Bytes()
		nextLine = restLn
		return restLn()
	}
	nextLine = initialLn
}

// Setup nextToken without input buffer.
func SetUnbefferedInput(r io.Reader) {
	buf := bufio.NewReader(r)
	var b []byte

	var i int
	nextToken = func() ([]byte, error) {
		var err error
		if i == len(b) {
			b, err = buf.ReadBytes('\n')
			if err != nil {
				return nil, err
			}
			i = 0
			j := len(b) - 1
			for 0 <= j && IsSpace(b[j]) {
				j--
			}
			b = b[0 : j+1]
		}
		for i < len(b) && IsSpace(b[i]) {
			i++
		}
		j := i
		for i < len(b) && !IsSpace(b[i]) {
			i++
		}
		if i == j {
			return nil, io.ErrUnexpectedEOF
		}
		return b[j:i], nil
	}
}

// -----------------------------------------------------------------------------

// IO functions

// Reads next token and return it as []byte
func readb() []byte {
	b, err := nextToken()
	if err != nil {
		panic(err)
	}
	return b[:len(b):len(b)]
}

// Reads next token and return it as string
func reads() string {
	return string(readb())
}

// Read next line as []byte.  Trailing '\n' will not be included.
// See also comments on readb()
func readbln() []byte {
	b, err := nextLine()
	if err != nil {
		panic(err)
	}
	return b[:len(b):len(b)]
}

// Read next line as string
func readsln() string {
	return string(readbln())
}

// Reads next token and return it as int64
func readll() int64 {
	i, err := strconv.ParseInt(reads(), 10, 64)
	if err != nil {
		panic(err.Error())
	}
	return i
}

// Reads next token and return it as int
func readi() int {
	return int(readll())
}

// Reads next token and return it as float64
func readf() float64 {
	f, err := strconv.ParseFloat(reads(), 64)
	if err != nil {
		panic(err.Error())
	}
	return f
}

// Write args to OutputWriter with the format f
func printf(f string, args ...interface{}) (int, error) {
	return fmt.Fprintf(OutputWriter, f, args...)
}

// Write args to OutputWriter without format
func println(args ...interface{}) (int, error) {
	return fmt.Fprintln(OutputWriter, args...)
}

// Write args to stderr with the format f
func eprintf(f string, args ...interface{}) (int, error) {
	return fmt.Fprintf(os.Stderr, f, args...)
}

// Write args to stderr without format
func eprintln(args ...interface{}) (int, error) {
	return fmt.Fprintln(os.Stderr, args...)
}

func dbgf(f string, args ...interface{}) {
	if !DEBUG {
		return
	}
	fmt.Fprintf(os.Stderr, f, args...)
}

func dbg(args ...interface{}) {
	if !DEBUG {
		return
	}
	fmt.Fprintln(os.Stderr, args...)
}

// -----------------------------------------------------------------------------

// Utilities

func sumSlice(a []int) int {
	var res int
	for _, v := range a {
		res += v
	}
	return res
}

func sumSlicell(a []int64) int64 {
	var res int64
	for _, v := range a {
		res += v
	}
	return res
}

func readInts(N int) (int, []int) {
	if N == 0 {
		N = readi()
	}
	a := make([]int, N)
	for i := range a {
		a[i] = readi()
	}
	return N, a
}

func readIntsll(N int) (int, []int64) {
	if N == 0 {
		N = readi()
	}
	a := make([]int64, N)
	for i := range a {
		a[i] = readll()
	}
	return N, a
}

// -----------------------------------------------------------------------------

// Simple math functions

const (
	// big prime
	INF  = 1000000007
	INF2 = 1000000009
	INF3 = 998244353
)

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

func minll(a, b int64) int64 {
	if a < b {
		return a
	}
	return b
}

func minf(a, b float64) float64 {
	if a < b {
		return a
	}
	return b
}

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

func maxll(a, b int64) int64 {
	if a < b {
		return b
	}
	return a
}

func maxf(a, b float64) float64 {
	if a < b {
		return b
	}
	return a
}

func abs(a int) int {
	if a < 0 {
		return -a
	}
	return a
}

func absll(a int64) int64 {
	if a < 0 {
		return -a
	}
	return a
}

func absf(a float64) float64 {
	if a < 0 {
		return -a
	}
	return a
}

// egcd(a, b) returns d, x, y:
//   d is gcd(a,b)
//   x, y are  integers that satisfy ax + by = d
func egcd(a, b int) (int, int, int) {
	if b == 0 {
		return a, 1, 0
	}
	d, x, y := egcd(b, a%b)
	return d, y, x - a/b*y
}

func egcdll(a, b int64) (int64, int64, int64) {
	if b == 0 {
		return a, 1, 0
	}
	d, x, y := egcdll(b, a%b)
	return d, y, x - a/b*y
}

func gcd(a, b int) int {
	d, _, _ := egcd(a, b)
	return d
}

func gcdll(a, b int64) int64 {
	d, _, _ := egcdll(a, b)
	return d
}

// set up IO functions
func init() {
	// for non-interactive
	SetInput(os.Stdin)
	SetOutput(os.Stdout)

	// Enable below when interactive.  Its ok to leave above intact.
	// SetInteractive(os.Stdout, os.Stdin)
}


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
}


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
}


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)
    }
}


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)
        }
}


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)
		}
	}

}


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


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


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


a,b,n=gets.split.map(&:to_i)
puts b-a+1>2*n ? ([*a..a+n-1],[*b-n+1..b]) : [*a..b]


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]


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


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);
		}
	}
}


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);
    }
}


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)
    }
}


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);
        }
    }

}


#![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);
    }
}


#![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);
    }
}


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)
}


//
//  main.swift
//  AtCoderSwift
//
//  Created by burita083 on 2020/08/25.
//  Copyright © 2020 burita083. All rights reserved.
//

import Foundation
func readInt() -> Int {
    return Int(readLine()!)!
}

func readInts() -> [Int] {
    return readLine()!.split(separator: " ").map { Int($0)! }
}

func readTwoInts() -> (a: Int, b: Int) {
    let ints = readLine()!.split(separator: " ").map { Int($0)! }
    return (a: ints[0], b: ints[1])
}

func abc080_b() {
    let N = readLine()!
    let sum = N.map { Int(String($0))! }.reduce(0, +)
    print(Int(N)! % sum == 0 ? "Yes" : "No")
}

//abc080_b()

func abc078_b() {
    let input = readInts()
    var X = input[0]
    let Y = input[1]
    let Z = input[2]
    var ans = 0
    X -= Y+Z*2
    ans += 1
    ans += X/(Y+Z)

    print(ans)
}

func abc085_b() {
    let N = readInt()
    var l: [Int] = []
    for _ in 0..<N {
        let d = readInt()
        l.append(d)
    }
    print(l.reduce([], { $0.contains($1) ? $0 : $0 + [$1] }).count)
}

func isSquare(n: Double) -> Bool {
    let sqrt = floor(n.squareRoot())
    return sqrt * sqrt == n
}

func abc077_b() {
    let N = readInt()
    for n in (1...N).reversed() {
        if isSquare(n: Double(n)) {
            print(n)
            return
        }
    }
}

func abc020_b () {
    let inputs = readInts()
    print(Int(String(inputs[0]) + String(inputs[1]))! * 2)
}

func abc073_b () {
    var ans = 0
    let N = readInt()
    for _ in 0..<N {
        let inputs = readInts()
        ans += inputs[1] - inputs[0] + 1
    }
    print(ans)
}

func abc026_b () {
    var evens: [Int] = []
    var odds: [Int] = []
    var all: [Int] = []
    let N = readInt()
    for _ in 0..<N {
        let R = readInt()
        all.append(R)
    }

    for (i, e) in all.sorted(by: >).enumerated() {
        if i % 2 == 0 {
            evens.append(e)
        } else {
            odds.append(e)
        }
    }
    let ans = evens.map { $0 * $0 }.reduce(0, +) - odds.map { $0 * $0 }.reduce(0, +)
    print(Double(ans) * Double.pi)
}

extension StringProtocol {
    var firstUppercased: String {
        return prefix(1).uppercased()  + self.lowercased().dropFirst()
    }
}

func abc012_b () {
    print(readLine()!.firstUppercased)

}

func abc007_b () {
    print(readLine()! == "a" ? -1 : "a")
}

func abc028_b () {
    let S = readLine()!
    let A = String(S.filter { $0 == "A" }.count)
    let B = String(S.filter { $0 == "B" }.count)
    let C = String(S.filter { $0 == "C" }.count)
    let D = String(S.filter { $0 == "D" }.count)
    let E = String(S.filter { $0 == "E" }.count)
    let F = String(S.filter { $0 == "F" }.count)
    print(A + " " + B + " " + C + " " + D + " " + E + " " + F)
}

func abc097_b () {
    let x = Double(Int(readLine()!)!)
    var ans: Double = 1
    for b in 2..<32 {
        var p: Double = 2
        while pow(Double(b), p) <= x {
            ans = max(ans, pow(Double(b), p))
            p += 1
        }
    }
    print(Int(ans))
}

func abc093_b () {
    var ans: [Int] = []
    let inputs = readInts()
    for x in inputs[0]..<inputs[0]+inputs[2] {
        ans.append(x)
    }

    for x in inputs[1]-inputs[2]+1...inputs[1] {
        if !ans.contains(x) {
            ans.append(x)
        }
    }
    ans.filter { $0 >= inputs[0] && $0 <= inputs[1] }.forEach { print($0) }

}

abc093_b()


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) }


//
//  main.swift
//  AtCoderSwift
//
//  Created by burita083 on 2020/08/25.
//  Copyright © 2020 burita083. All rights reserved.
//

import Foundation
func readInt() -> Int {
    return Int(readLine()!)!
}

func readInts() -> [Int] {
    return readLine()!.split(separator: " ").map { Int($0)! }
}

func readTwoInts() -> (a: Int, b: Int) {
    let ints = readLine()!.split(separator: " ").map { Int($0)! }
    return (a: ints[0], b: ints[1])
}

func abc080_b() {
    let N = readLine()!
    let sum = N.map { Int(String($0))! }.reduce(0, +)
    print(Int(N)! % sum == 0 ? "Yes" : "No")
}

//abc080_b()

func abc078_b() {
    let input = readInts()
    var X = input[0]
    let Y = input[1]
    let Z = input[2]
    var ans = 0
    X -= Y+Z*2
    ans += 1
    ans += X/(Y+Z)

    print(ans)
}

func abc085_b() {
    let N = readInt()
    var l: [Int] = []
    for _ in 0..<N {
        let d = readInt()
        l.append(d)
    }
    print(l.reduce([], { $0.contains($1) ? $0 : $0 + [$1] }).count)
}

func isSquare(n: Double) -> Bool {
    let sqrt = floor(n.squareRoot())
    return sqrt * sqrt == n
}

func abc077_b() {
    let N = readInt()
    for n in (1...N).reversed() {
        if isSquare(n: Double(n)) {
            print(n)
            return
        }
    }
}

func abc020_b () {
    let inputs = readInts()
    print(Int(String(inputs[0]) + String(inputs[1]))! * 2)
}

func abc073_b () {
    var ans = 0
    let N = readInt()
    for _ in 0..<N {
        let inputs = readInts()
        ans += inputs[1] - inputs[0] + 1
    }
    print(ans)
}

func abc026_b () {
    var evens: [Int] = []
    var odds: [Int] = []
    var all: [Int] = []
    let N = readInt()
    for _ in 0..<N {
        let R = readInt()
        all.append(R)
    }

    for (i, e) in all.sorted(by: >).enumerated() {
        if i % 2 == 0 {
            evens.append(e)
        } else {
            odds.append(e)
        }
    }
    let ans = evens.map { $0 * $0 }.reduce(0, +) - odds.map { $0 * $0 }.reduce(0, +)
    print(Double(ans) * Double.pi)
}

extension StringProtocol {
    var firstUppercased: String {
        return prefix(1).uppercased()  + self.lowercased().dropFirst()
    }
}

func abc012_b () {
    print(readLine()!.firstUppercased)

}

func abc007_b () {
    print(readLine()! == "a" ? -1 : "a")
}

func abc028_b () {
    let S = readLine()!
    let A = String(S.filter { $0 == "A" }.count)
    let B = String(S.filter { $0 == "B" }.count)
    let C = String(S.filter { $0 == "C" }.count)
    let D = String(S.filter { $0 == "D" }.count)
    let E = String(S.filter { $0 == "E" }.count)
    let F = String(S.filter { $0 == "F" }.count)
    print(A + " " + B + " " + C + " " + D + " " + E + " " + F)
}

func abc097_b () {
    let x = Double(Int(readLine()!)!)
    var ans: Double = 1
    for b in 2..<32 {
        var p: Double = 2
        while pow(Double(b), p) <= x {
            ans = max(ans, pow(Double(b), p))
            p += 1
        }
    }
    print(Int(ans))
}

func abc093_b () {
    var ans: [Int] = []
    let inputs = readInts()
    for x in inputs[0]..<inputs[0]+inputs[2] {
        ans.append(x)
    }

    for x in inputs[1]-inputs[2]...inputs[1] {
        if !ans.contains(x) {
            ans.append(x)
        }
    }
    ans.filter { $0 >= inputs[0] && $0 <= inputs[1] }.forEach { print($0) }

}

abc093_b()


//
//  main.swift
//  AtCoderSwift
//
//  Created by burita083 on 2020/08/25.
//  Copyright © 2020 burita083. All rights reserved.
//

import Foundation
func readInt() -> Int {
    return Int(readLine()!)!
}

func readInts() -> [Int] {
    return readLine()!.split(separator: " ").map { Int($0)! }
}

func readTwoInts() -> (a: Int, b: Int) {
    let ints = readLine()!.split(separator: " ").map { Int($0)! }
    return (a: ints[0], b: ints[1])
}

func abc080_b() {
    let N = readLine()!
    let sum = N.map { Int(String($0))! }.reduce(0, +)
    print(Int(N)! % sum == 0 ? "Yes" : "No")
}

//abc080_b()

func abc078_b() {
    let input = readInts()
    var X = input[0]
    let Y = input[1]
    let Z = input[2]
    var ans = 0
    X -= Y+Z*2
    ans += 1
    ans += X/(Y+Z)

    print(ans)
}

func abc085_b() {
    let N = readInt()
    var l: [Int] = []
    for _ in 0..<N {
        let d = readInt()
        l.append(d)
    }
    print(l.reduce([], { $0.contains($1) ? $0 : $0 + [$1] }).count)
}

func isSquare(n: Double) -> Bool {
    let sqrt = floor(n.squareRoot())
    return sqrt * sqrt == n
}

func abc077_b() {
    let N = readInt()
    for n in (1...N).reversed() {
        if isSquare(n: Double(n)) {
            print(n)
            return
        }
    }
}

func abc020_b () {
    let inputs = readInts()
    print(Int(String(inputs[0]) + String(inputs[1]))! * 2)
}

func abc073_b () {
    var ans = 0
    let N = readInt()
    for _ in 0..<N {
        let inputs = readInts()
        ans += inputs[1] - inputs[0] + 1
    }
    print(ans)
}

func abc026_b () {
    var evens: [Int] = []
    var odds: [Int] = []
    var all: [Int] = []
    let N = readInt()
    for _ in 0..<N {
        let R = readInt()
        all.append(R)
    }

    for (i, e) in all.sorted(by: >).enumerated() {
        if i % 2 == 0 {
            evens.append(e)
        } else {
            odds.append(e)
        }
    }
    let ans = evens.map { $0 * $0 }.reduce(0, +) - odds.map { $0 * $0 }.reduce(0, +)
    print(Double(ans) * Double.pi)
}

extension StringProtocol {
    var firstUppercased: String {
        return prefix(1).uppercased()  + self.lowercased().dropFirst()
    }
}

func abc012_b () {
    print(readLine()!.firstUppercased)

}

func abc007_b () {
    print(readLine()! == "a" ? -1 : "a")
}

func abc028_b () {
    let S = readLine()!
    let A = String(S.filter { $0 == "A" }.count)
    let B = String(S.filter { $0 == "B" }.count)
    let C = String(S.filter { $0 == "C" }.count)
    let D = String(S.filter { $0 == "D" }.count)
    let E = String(S.filter { $0 == "E" }.count)
    let F = String(S.filter { $0 == "F" }.count)
    print(A + " " + B + " " + C + " " + D + " " + E + " " + F)
}

func abc097_b () {
    let x = Double(Int(readLine()!)!)
    var ans: Double = 1
    for b in 2..<32 {
        var p: Double = 2
        while pow(Double(b), p) <= x {
            ans = max(ans, pow(Double(b), p))
            p += 1
        }
    }
    print(Int(ans))
}

func abc093_b () {
    var ans: [Int] = []
    let inputs = readInts()
    for x in inputs[0]..<inputs[0]+inputs[2] {
        ans.append(x)
    }

    for x in inputs[1]..<inputs[1]+inputs[2] {
        if !ans.contains(x) {
            ans.append(x)
        }
    }
    ans.filter { $0 >= inputs[0] && $0 <= inputs[1] }.forEach { print($0) }

}

abc093_b()


//
//  main.swift
//  AtCoderSwift
//
//  Created by burita083 on 2020/08/25.
//  Copyright © 2020 burita083. All rights reserved.
//

import Foundation
func readInt() -> Int {
    return Int(readLine()!)!
}

func readInts() -> [Int] {
    return readLine()!.split(separator: " ").map { Int($0)! }
}

func readTwoInts() -> (a: Int, b: Int) {
    let ints = readLine()!.split(separator: " ").map { Int($0)! }
    return (a: ints[0], b: ints[1])
}

func abc080_b() {
    let N = readLine()!
    let sum = N.map { Int(String($0))! }.reduce(0, +)
    print(Int(N)! % sum == 0 ? "Yes" : "No")
}

//abc080_b()

func abc078_b() {
    let input = readInts()
    var X = input[0]
    let Y = input[1]
    let Z = input[2]
    var ans = 0
    X -= Y+Z*2
    ans += 1
    ans += X/(Y+Z)

    print(ans)
}

func abc085_b() {
    let N = readInt()
    var l: [Int] = []
    for _ in 0..<N {
        let d = readInt()
        l.append(d)
    }
    print(l.reduce([], { $0.contains($1) ? $0 : $0 + [$1] }).count)
}

func isSquare(n: Double) -> Bool {
    let sqrt = floor(n.squareRoot())
    return sqrt * sqrt == n
}

func abc077_b() {
    let N = readInt()
    for n in (1...N).reversed() {
        if isSquare(n: Double(n)) {
            print(n)
            return
        }
    }
}

func abc020_b () {
    let inputs = readInts()
    print(Int(String(inputs[0]) + String(inputs[1]))! * 2)
}

func abc073_b () {
    var ans = 0
    let N = readInt()
    for _ in 0..<N {
        let inputs = readInts()
        ans += inputs[1] - inputs[0] + 1
    }
    print(ans)
}

func abc026_b () {
    var evens: [Int] = []
    var odds: [Int] = []
    var all: [Int] = []
    let N = readInt()
    for _ in 0..<N {
        let R = readInt()
        all.append(R)
    }

    for (i, e) in all.sorted(by: >).enumerated() {
        if i % 2 == 0 {
            evens.append(e)
        } else {
            odds.append(e)
        }
    }
    let ans = evens.map { $0 * $0 }.reduce(0, +) - odds.map { $0 * $0 }.reduce(0, +)
    print(Double(ans) * Double.pi)
}

extension StringProtocol {
    var firstUppercased: String {
        return prefix(1).uppercased()  + self.lowercased().dropFirst()
    }
}

func abc012_b () {
    print(readLine()!.firstUppercased)

}

func abc007_b () {
    print(readLine()! == "a" ? -1 : "a")
}

func abc028_b () {
    let S = readLine()!
    let A = String(S.filter { $0 == "A" }.count)
    let B = String(S.filter { $0 == "B" }.count)
    let C = String(S.filter { $0 == "C" }.count)
    let D = String(S.filter { $0 == "D" }.count)
    let E = String(S.filter { $0 == "E" }.count)
    let F = String(S.filter { $0 == "F" }.count)
    print(A + " " + B + " " + C + " " + D + " " + E + " " + F)
}

func abc097_b () {
    let x = Double(Int(readLine()!)!)
    var ans: Double = 1
    for b in 2..<32 {
        var p: Double = 2
        while pow(Double(b), p) <= x {
            ans = max(ans, pow(Double(b), p))
            p += 1
        }
    }
    print(Int(ans))
}

func abc093_b () {
    var ans: [Int] = []
    let inputs = readInts()
    for x in inputs[0]..<inputs[0]+inputs[2] {
        ans.append(x)
    }

    for x in inputs[1]..<inputs[1]+inputs[2] {
        ans.append(x)
    }
    ans.forEach { print($0) }

}

abc093_b()


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()


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"));


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()));


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);


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);


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"));


S=input()

for i in range(3):
    if S[i]==S[i+1]:
        ans='Bad'
        break
    else :
        ans='Good'
print(ans)


S = input()
A = "Good"
for i in range (3):
    if S[i] == S[i + 1]:
        A = "Bad"
print(A)


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')


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")


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)


S = input()
ans = "Good"
for i in range(2):
  if S[i] == S[i+1]:
    ans = "Bad"
    break
print(ans)


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");
        }
    }
}


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");
            }
        }
    }

}


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");
  }
}


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");
        }
    }
}


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");
		}
	}
}


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")
  }
}


#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;
}


#include<stdio.h>
#include<math.h>
#include<algorithm>
#include<queue>
#include<deque>
#include<stack>
#include<string>
#include<string.h>
#include<vector>
#include<set>
#include<map>
#include<bitset>
#include<stdlib.h>
#include<cassert>
#include<time.h>
#include<bitset>
using namespace std;
const long long mod=1000000007;
const long long inf=mod*mod;
const long long d2=(mod+1)/2;
const double EPS=1e-10;
const double INF=1e+10;
const double PI=acos(-1.0);
const int C_SIZE = 210000;
long long fact[C_SIZE];
long long finv[C_SIZE];
long long inv[C_SIZE];
// long long C(int a,int b){
// 	if(a<b||b<0)return 0;
// 	return fact[a]*finv[b]%mod*finv[a-b]%mod;
// }
void init_C(int n){
	fact[0]=finv[0]=inv[1]=1;
	for(int i=2;i<n;i++){
		inv[i]=(mod-(mod/i)*inv[mod%i]%mod)%mod;
	}
	for(int i=1;i<n;i++){
		fact[i]=fact[i-1]*i%mod;
		finv[i]=finv[i-1]*inv[i]%mod;
	}
}
int ABS(int a){return max(a,-a);}
long long ABS(long long a){return max(a,-a);}
double ABS(double a){return max(a,-a);}
// ここから編集しろ
char in[5];
int main(){
	scanf("%s",in);
	if(in[0]==in[1]||in[1]==in[2]||in[2]==in[3])printf("Bad\n");
	else printf("Good\n");
}


#include<stdio.h>
int main(){

int num;
scanf("%d",&num);
int one,two,three,four;
four=num%10;
num/=10;
three=num%10;
num/=10;
two=num%10;
num/=10;
one=num;

if(one==two || two==three || three==four){
printf("Bad");}
else{
printf("Good");}

return 0;

}


#include <iostream>

using namespace std;

int main(){
  strint s;
  cin>>s;
  char a='a';
  bool flag = true;
  for(int i=0;i<s.size();i++){
    if(s[i]==a){
      flag=false;
    }
    a=s[i];
  }
  if(flag)cout<<"Good"<<endl;
  else cout<<"Bad"<<endl;

}
#include <iostream>

using namespace std;

int main(){
  string s;
  cin>>s;
  char a='a';
  bool flag = true;
  for(int i=0;i<s.size();i++){
    if(s[i]==a){
      flag=false;
    }
    a=s[i];
  }
  if(flag)cout<<"Good"<<endl;
  else cout<<"Bad"<<endl;

}


#include <iostream>

using namespace std;

int main(){
  strint s;
  cin>>s;
  char a='a';
  bool flag = true;
  for(int i=0;i<s.size();i++){
    if(s[i]==a){
      flag=false;
    }
    a=s[i];
  }
  if(flag)cout<<"Good"<<endl;
  else cout<<"Bad"<<endl;

}


#include<stdio.h>
#include<iostream>
#include<string>
using namespace std;
int main(){
  string s; scanf("%s",&s);
  for(int i = 0;i < 3;i++){
    if(s[i] == s[i + 1]){
      cout << "Bad" << endl;
      return 0;
    }
  }
  cout << "Good" << endl;
  return 0;
}


//Security
#include<stdio.h>
int main(){
    char s[4];
    scanf("%s",s);
    for(int i=0;i<3;i++){
        if(s[i]==s[i+1]){
            printf("Bad\n");
            return 0;
        }
    }
    printf("Good\n");
    return 0;
}


#include<stdio.h>

int main(){
  int i;
  char s[4];
  scanf("%s",s);
  for(i=1;i<4;i++){
    if(s[i-1]==s[i]){
      printf("Bad\n");
      return 0;
    }
  }
  printf("Good\n");
  return 0;
}


#include <stdio.h>

int main(){
  char s[4];
  for(int i=0;i<4;i++){
    scanf("%c",&s[i]);
  }
  int code = 0;
  for(int j=0;j<3;j++){
    if(s[j+1] == s[j]){
      code = 1;
    }
  }
  if(code == 1){
    printf("Bad\n");
  }else{
    printf("Good\n");
  }
  return 0;
}


#include<stdio.h>

int quotient(int dividend, int divisor);
int add(int a, int b, int divisor);
int lcm(int a, int b);

int main(void){
    int ans;
    int a,b,c,d;
    scanf("%d %d %d %d", &a,&b,&c,&d);
    ans = b-a+1;
    ans -= add(a, b, c);
    ans -= add(a, b, d);
    ans += add(a, b, lcm(c, d));
    printf("%d", ans);
    return 0;
}

int add(int a, int b, int divisor){
    int ans = 0;
    ans += quotient(b, divisor);
    ans -= quotient(a, divisor);
    if (a % divisor == 0){
        ans += 1;
    }
    return ans;
}

// 商を返す関数
int quotient(int dividend, int divisor){
    int remainder, ans;
    remainder = dividend % divisor;
    ans = (dividend - remainder) / divisor;
    return ans;
}

int lcm(int a, int b){
    int r, x, tmp;
    x = a * b;

    /* 自然数 a > b を確認・入替 */
    if(a<b){
    tmp = a;
    a = b;
    b = tmp;
    }

    /* ユークリッドの互除法 */
    r = a % b;
    while(r!=0){
    a = b;
    b = r;
    r = a % b;
    }

    /* 最小公倍数を出力 */
    return x/b;

}


#include <stdio.h>
main() {
	char pass[4];
	int a=0;
	scanf("%s",&pass );
	for (int i= 0; i<3; i++) {
		if (pass[i]!=pass[i+1]) {
			continue;
		} else {
			a=1;
		}
	}
	if (a==1) {
		printf("Bad");
	} else  {
		printf("Good");
	}
}


#include <stdio.h>
main() {
	char pass[4];
	int a=0;
	scanf("%s",&pass );

	for (int i= 0; i<3; i++) {
		if (pass[i]!=pass[i+1]) {
			continue;
		} else {
			a=1;
		}
	}
	if (a==1) {
		printf("Bad");
	} else printf("Good");
}


"use strict";

const main = arg => {
  let Num = arg.split("");
  let ans = "Good";
  for(let i = 0; i < 3; i++){
  	if(Num[i] == Num[i+1]){
       ans = "Bad";
    }
  }
  console.log(ans);
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));


function Main(input) {
    input = input.trim()
  input = input.split("").map(Number);
  if(input[0]==input[1]||input[2]==input[1]||input[2]==input[3]) console.log("Bad");
  else console.log("Good")
}Main(require("fs").readFileSync("/dev/stdin", "utf8"));


// inputに入力データ全体が入る
function Main(input) {
  var s;
  s = input.split('\n')[0];

  for(var i = 0; i < s.length - 1; i++){
    if(s.charAt(i) === s.charAt(i + 1)){
      console.log('Bad');
      return;
    }
  }

  console.log('Good');

}
//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));


const Main = input => {
    const array = input.split("");
    const result = new Set(array);
    if(array.length === result.size) {
        console.log("Good");
    } else {
        console.log("Bad");
    }
}

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


function main(input) {
    const s = input.split('');
    let ans = 'Good';
    for (let i = 0; i < s.length - 1; i++) {
        if (s[i] === s[i + 1]) {
            ans = 'Bad';
        }
    }
    console.log(ans);
}

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


function Main(input) {
    input = input.trim()
  input = input.split("").map(Number);
  if(input[0]==input[1]||input[2]==input[1]||input[2]==input[3]) console.log("Good");
  else console.log("Bad")
}Main(require("fs").readFileSync("/dev/stdin", "utf8"));


package main

import (
  "fmt"
)

func main() {
  var s string
  fmt.Scan(&s)
  ans := "Good"
  for i := 0; i < 3; i++ {
    if s[i] == s[i+1] {
      ans = "Bad"
      break
    }
  }
  fmt.Println(ans)
}


package main

import (
	"bufio"
	"fmt"
	"os"
)

const (
	initialBufSize = 1e4
	maxBufSize     = 1e6 + 7
)

var buf []byte = make([]byte, maxBufSize)
var sc = bufio.NewScanner(os.Stdin)

func init() {
	sc.Split(bufio.ScanWords)
	sc.Buffer(buf, maxBufSize)
}

func main() {
	S := nextLine()
	var prev rune
	for _, Si := range S {
		if Si == prev {
			fmt.Println("Bad")
			return
		}
		prev = Si
	}
	fmt.Println("Good")
}

func nextLine() string {
	sc.Scan()
	return sc.Text()
}


package main

import "fmt"

func main() {
	var s string
	fmt.Scan(&s)

	if s[0] == s[1] {
		fmt.Println("Bad")
		return
	}
	if s[1] == s[2] {
		fmt.Println("Bad")
		return
	}
	if s[2] == s[3] {
		fmt.Println("Bad")
		return
	}
	fmt.Println("Good")
}


package main

import "fmt"

func main() {
	var s []byte
	fmt.Scan(&s)

	m :=make(map[string]int, len(s))
	for i := 0;i < len(s);i++ {
		m[string(s[i])]++
		if m[string(s[i])] > 1 {
			fmt.Println("Bad")
			return
		}
	}

	fmt.Println("Good")
}


package main

import "fmt"

func main() {
	var s []byte
	fmt.Scan(&s)

	m :=make(map[string]int, len(s))
	for i := 0;i < len(s);i++ {
		m[string(s[i])]++
		if m[string(s[i])] > 2 {
			fmt.Println("Bad")
			return
		}
	}

	fmt.Println("Good")
}


package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

var sc = bufio.NewScanner(os.Stdin)

func main() {
	scanInit()

	s := nextStr()

	for i := 1; i < 3; i++ {
		if s[i-1] == s[i] {
			fmt.Println("Bad")
			return
		}
	}

	fmt.Println("Good")

}

// ---- readfunc
func scanInit() {
	const cap = 64 * 1024
	var buf = make([]byte, cap)
	sc.Buffer(buf, cap)
	sc.Split(bufio.ScanWords)
	return
}
func nextInt() int {
	sc.Scan()
	i, e := strconv.Atoi(sc.Text())
	if e != nil {
		panic(e)
	}
	return i
}
func nextStr() string {
	sc.Scan()
	return sc.Text()
}


A=gets.chomp.split('').map{|i| i.to_i}
for i in 0..2
	if(A[i] == A[i+1])
		puts "Bad"
		exit(0)
	end
end
puts "Good"


s=gets.chomp.chars.map(&:to_i)
if s[0]==s[1]||s[1]==s[2]||s[2]==s[3]
  puts "Bad"
else
  puts "Good"
end


input = gets.strip
if((input[0] == input[1]) || (input[1] == input[2]) || (input[2] == input[3]))
  puts "Bad"
else
  puts "Good"
end


n,l=gets.split.map &:to_i
a=(l..n+l-1).to_a
max=a[0]
a.each{|i|
max=[i.abs,max.abs].min==i.abs? i : max
}
puts a.sum-max


s=gets.chomp.split("")
ans=s.each_cons(2).count{|a|a[0]==b[1]}
puts ans>=1? "Bad":"Good"


s=gets.chomp.split("")
ans=s.cons_each(2).count{|a|a[0]==b[1]}
puts ans>=1? "Bad":"Good"


use std::io::*;
use std::str::FromStr;

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")
}

fn main() {
    let s: Vec<char> = read::<String>().chars().collect();
    let mut cnt = 0;
    if s[0] == s[1] { cnt += 1; }
    if s[1] == s[2] { cnt += 1; }
    if s[2] == s[3] { cnt += 1; }
    let ans = if cnt > 0 { "Bad" } else { "Good" };
    println!("{}", ans);
}


#[allow(unused_macros)]
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)*}
    };
}

#[allow(unused_macros)]
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)*}
    };
}

#[allow(unused_macros)]
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")
    };
}

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

fn f(d1: &Vec<i32>, d2: &Vec<i32>) -> bool {
    for i in 0..d1.len() {}

    return true;
}

use std::cmp;
use std::iter::Iterator;

fn main() {
    input! {
        n:chars,
    }

    for i in 1..n.len() {
        if n[i - 1] == n[i] {
            println!("Bad");
            return;
        }
    }
    println!("Good");

}


fn read_stdin() -> String {
    use std::io::Read;
    let mut input = String::new();
    std::io::stdin().read_to_string(&mut input).unwrap();
    input
}

fn scan<'a, I: Iterator<Item = &'a str>, T: std::str::FromStr>(tokens: &mut I) -> T {
    tokens.next().unwrap().parse().ok().unwrap()
}

fn main() {
    let input = read_stdin();
    let tokens = &mut input.split_whitespace();
    let s: String = scan(tokens);
    let s = s.as_bytes();
    if s[0] == s[1] || s[1] == s[2] || s[2] == s[3] {
        println!("Bad");
    } else {
        println!("Good");
    }
}


#[allow(unused_imports)]
use std::collections::HashSet;
use std::str::Chars;

fn read<T: std::str::FromStr>() -> T {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim().parse().ok().unwrap()
}

#[allow(dead_code)]
fn read_vec<T: std::str::FromStr>() -> Vec<T> {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim()
        .split_whitespace()
        .map(|e| e.parse().ok().unwrap())
        .collect()
}

fn main() {
    let s = read::<String>();
    let s1 = s.chars();

    let answer = solve(s1);
    if answer {
        println!("BAD");
    } else {
        println!("GOOD")
    }
}

fn solve(s: Chars) -> bool {
    let mut prev  = 'X';
    for c in s {
        if c == prev {
            return true;
        }
        prev = c
    }

    return false;
}


fn main() {
  proconio::input!{
    mut s: proconio::Chars,
  }
  let n = s.len();
  s.dedup();
  if s.len() < n { println!("Bad") }
  else { println!("Good") }
}


#[allow(unused_macros)]
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)*}
    };
}

#[allow(unused_macros)]
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)*}
    };
}

#[allow(unused_macros)]
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")
    };
}

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

fn f(d1: &Vec<i32>, d2: &Vec<i32>) -> bool {
    for i in 0..d1.len() {}

    return true;
}

use std::cmp;
use std::iter::Iterator;

fn main() {
    input! {
        s:chars,
    }

    let mut ans = false;
    for i in 0..2 {
        if s[i] == s[i+1] {
            ans = true;
            break;
        }
    }

    if ans {
        println!("Bad")
    }else{
        println!("Good")
    }

}


var s=readLine()!
let start=s.startIndex
let end=s.endIndex
var index0=start
var judge=0
for _ in 0...3{
  var index1=s.index(after: index0)
  if s[index0]==s[index1]{
    judge=1
  }
  index0=s.index(after: index0)
}
if judge==0{
  print("Good")
}else{
  print("Bad")
}


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")
  }
}


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")
  }
}


func readInts() -> [Int] {
    return readLine()!.split(separator: " ").map { Int($0)! }
}
let suuji = readInts()
let n = suuji[0]
let l = suuji[1]
var sum = 0
var min = l
for i in 2...n {
  var b = l + i - 1
  sum+=b
  if (abs(b)<abs(min)) {
    sum-=b
    sum+=min
    min=b
  }
}
print(sum)


var s=readLine()!
let start=s.startIndex
let end=s.endIndex
var index0=start
var judge=0
for _ in 0...3{
  index1=s.index(after: index0)
  if s[index0]==s[index1]{
    judge=1
  }
  index0{after: index0)
}
if judge==0{
  print("Good")
}else{
  print("Bad")
}


#include<stdio.h>
#include<stdlib.h>
#include<iostream>
#include<string>
#include<algorithm>
#include<vector>
#include<limits>
#include<numeric>
#include<type_traits>
#include<math.h>
#include<fstream>
#include<set>
using namespace std;
typedef long long ll;

#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define repi(i,a,b) for(int i = (int)(a); i < (int)(b); i++)
#define out(str) cout << str << endl
#define ALL(a) (a).begin(),(a).end()
#define INF (1<<29)

template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }

string S;

int main(){
    cin>>S;
    if(S[0]==S[1]||S[1]==S[2]||S[2]==S[3])out("Bad");
    else out("Good");

}


import * as fs from 'fs';

//in
// 3778
//out
// Bad
const main = (inp: string) => {

    if (inp[0] === inp[1] || inp[1] === inp[2] || inp[2] === inp[3]) {
        console.log('Bad');

    } else {
        console.log('Good');
    }
};
main(fs.readFileSync('/dev/stdin', 'utf8').trim());


import * as fs from "fs";

const input = (fs.readFileSync("/dev/stdin", "utf8") as string).split("\n");
//const n = +input[0];
//const a = [];
//for(let i=0;i<n;i++){
//	a.push(input[i+1].split(" ").map((x:string):number=>+x));
//}

//const [n, m] = input[0].split(" ").map((x: string): number => +x);
//const a = input[1].split(" ").map((x: string): number => +x);

function compareFunc(a, b){
    return a-b;
}

const s: string[] = input[0].split('');

if(s[0] === s[1] || s[1] === s[2] || s[2] === s[3]){
    console.log('Bad');
}else{
    console.log('Good');
}


const input=require('fs').readFileSync('/dev/stdin', 'utf8').split(/[\s]/);const nin=()=>{const r = input[0];input.shift();return Number(r)};const nrin=(n)=>{const a:number[]=[];rep(n,()=>a.push(nin()));return a};const sin=()=>{const r = input[0];input.shift();return String(r)};const out=(...a)=>{console.log(...a)};const floor=(a)=>{return Math.floor(a)};const abs=(a)=>{return Math.abs(a)};const min=(...a)=>{return Math.min(...a)};const max=(...a)=>{return Math.max(...a)};const rep=(n, callback)=>{for(let i = 0;i < n; i++){callback()}};const strrep=(s, i, v)=>{return s.slice(0, i)+v+s.slice(i+1);};const permutation=({result=[],pre=[],post,n=post.length})=>{if(n>0){post.forEach((_,i)=>{const rest=[...post];const elem=rest.splice(i, 1);permutation({result, pre: [...pre,...elem],post:rest,n:n-1})})}else{result.push(pre)}return result};const sw=(s,a:any[],op:'=='|'>='|'>'|'<='|'<'='==')=>{for(let i=0;i<a.length;i+=2){if(op==='=='){if(s==a[i])return a[i+1]}else if(op==='>='){if(s>=a[i])return a[i+1]}else if(op==='<='){if(s<=a[i])return a[i+1]}else if(op==='>'){if(s>a[i])return a[i+1]}else if(op==='<'){if(s<a[i])return a[i+1]}}return a[a.length-1];};const or=(a,...b)=>{for(let i=0;i<b.length;i++)if(a==b[i])return true;return false};const maxindex=(...a)=>{return a.indexOf(Math.max.apply(null,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 ceil=a=>{return Math.ceil(a)};const srin=s=>{const a:string[]=[];rep(s,()=>a.push(sin()));return a};let ssinteger=-1;const ssin=()=>{ssinteger++;return input[0][ssinteger]};
const main = ()=>{
  let a=[ssin(),ssin(),ssin(),ssin()]
  out(a[0]==a[1]||a[1]==a[2]||a[2]==a[3]?'Bad':'Good')
}
main()


import * as fs from 'fs';

//in
// 3778
//out
// Bad
const main = (inp: string) => {

    if (inp[0] === inp[1] || inp[1] === inp[2] || inp[2] === inp[3]) {
        console.log('Bad');

    } else {
        console.log('Yes');
    }

};

main(fs.readFileSync('/dev/stdin', 'utf8').trim());


import * as fs from "fs";

const input = (fs.readFileSync("/dev/stdin", "utf8") as string).split("\n");
//const n = +input[0];
//const a = [];
//for(let i=0;i<n;i++){
//	a.push(input[i+1].split(" ").map((x:string):number=>+x));
//}

//const [n, m] = input[0].split(" ").map((x: string): number => +x);
//const a = input[1].split(" ").map((x: string): number => +x);

function compareFunc(a, b){
    return a-b;
}

const s: string[] = input[0].split('').sort();

if(s[0] === s[1] || s[1] === s[2] || s[2] === s[3]){
    console.log('Bad');
}else{
    console.log('Good');
}