use std::cmp::*;
use std::io::*;

fn main() {
    let mut s: String = String::new();
    std::io::stdin().read_to_string(&mut s).ok();
    let mut itr = s.trim().split_whitespace();
    let h: usize = itr.next().unwrap().parse().unwrap();
    let w: usize = itr.next().unwrap().parse().unwrap();
    let g: Vec<Vec<char>> = (0..h)
        .map(|_| itr.next().unwrap().chars().collect())
        .collect();

    let mut samer = vec![true; h];
    for i in 0..h {
        for j in 1..w {
            if g[i][0] != g[i][j] {
                samer[i] = false;
            }
        }
    }
    let mut samec = vec![true; w];
    for i in 0..w {
        for j in 1..h {
            if g[0][i] != g[j][i] {
                samec[i] = false;
            }
        }
    }

    let mut out = Vec::new();
    for i in 0..h {
        if samer[i] {
            continue;
        }
        for j in 0..w {
            if samec[j] {
                continue;
            }
            write!(out, "{}", g[i][j]).ok();
        }
        writeln!(out, "").ok();
    }
    stdout().write_all(&out).unwrap();
}


use std::io::BufRead;
const DEBUG: bool = false;
fn main() {
    let mut f = read_field();
    let mut col = 0;
    while col < f.w as usize {
        while col < f.w as usize && f.is_column_empty(col) {
            f.remove_column(col);
        }
        col += 1;
    }
    let mut row = 0;
    while row < f.h as usize {
        while row < f.h as usize && f.is_row_empty(row) {
            f.remove_row(row);
        }
        row += 1;
    }
    f.show();
}

fn read_field() -> Field {
    let stdin = std::io::stdin();
    let mut input = stdin.lock();
    let mut l = String::new();
    let _ = input.read_line(&mut l);
    let hw: Vec<u32> = l
        .split_whitespace()
        .map(|n| n.parse().expect("readnumerror!"))
        .collect();
    let h = hw[0];
    let w = hw[1];
    let mut f: Vec<Cell> = Vec::with_capacity((h * w) as usize);
    for line in input.lines() {
        for c in line.expect("read line error").trim().chars() {
            match c {
                '.' => f.push(false),
                '#' => f.push(true),
                _ => panic!(format!("unexpected char {}", c)),
            }
        }
    }
    Field {
        h: h,
        w: w,
        field: f,
    }
}

struct Field {
    h: u32,
    w: u32,
    field: Vec<Cell>,
}

impl Field {
    fn is_column_empty(&self, n: usize) -> bool {
        !self
            .field
            .iter()
            .skip(n)
            .step_by(self.w as usize)
            .any(|&b| b)
    }
    fn is_row_empty(&self, n: usize) -> bool {
        if DEBUG {
            println!(
                "DEBUG: n {} f w{:?} h{:?}, f{:?}",
                n, self.w, self.h, self.field
            );
        }
        !self
            .field
            .iter()
            .skip(n * self.w as usize)
            .take(self.w as usize)
            .any(|&b| b)
    }
    fn remove_column(&mut self, n: usize) {
        if DEBUG {
            self.show();
            println!("|||||||||||@@@@");
        }
        let mut l = n;
        for _ in 0..self.h {
            self.field.remove(l);
            l += self.w as usize - 1;
        }
        self.w -= 1;
    }
    fn remove_row(&mut self, n: usize) {
        if DEBUG {
            self.show();
            println!("@@@@@@@@@@@@@@@");
        }
        for _ in 0..self.w {
            self.field.remove(n * self.w as usize);
        }
        self.h -= 1;
    }

    fn show(&self) {
        for y in 0..self.h as usize {
            let line: String = self.field[y * self.w as usize..(y + 1) * self.w as usize]
                .iter()
                .map(|&c| if c { '#' } else { '.' })
                .collect();
            println!("{}", line);
        }
    }
}

type Cell = bool;


use std::io::BufRead;
const DEBUG: bool = false;
fn main() {
    let mut f = read_field();
    let mut col = 0;
    while col < f.w as usize {
        while col < f.w as usize && f.is_column_empty(col) {
            f.remove_column(col);
        }
        col += 1;
    }
    let mut row = 0;
    while row < f.h as usize {
        while row < f.h as usize && f.is_row_empty(row) {
            f.remove_row(row);
        }
        row += 1;
    }
    f.show();
}

fn read_field() -> Field {
    let stdin = std::io::stdin();
    let mut input = stdin.lock();
    let mut l = String::new();
    let _ = input.read_line(&mut l);
    let hw: Vec<u32> = l
        .split_whitespace()
        .map(|n| n.parse().expect("readnumerror!"))
        .collect();
    let h = hw[0];
    let w = hw[1];
    let mut f: Vec<Cell> = Vec::with_capacity((h * w) as usize);
    for line in input.lines() {
        for c in line.expect("read line error").trim().chars() {
            match c {
                '.' => f.push(false),
                '#' => f.push(true),
                _ => panic!(format!("unexpected char {}", c)),
            }
        }
    }
    Field { h, w, field: f }
}

struct Field {
    h: u32,
    w: u32,
    field: Vec<Cell>,
}

impl Field {
    fn is_column_empty(&self, n: usize) -> bool {
        !self
            .field
            .iter()
            .skip(n)
            .step_by(self.w as usize)
            .any(|&b| b)
    }
    fn is_row_empty(&self, n: usize) -> bool {
        if DEBUG {
            println!(
                "DEBUG: n {} f w{:?} h{:?}, f{:?}",
                n, self.w, self.h, self.field
            );
        }
        !self
            .field
            .iter()
            .skip(n * self.w as usize)
            .take(self.w as usize)
            .any(|&b| b)
    }
    fn remove_column(&mut self, n: usize) {
        if DEBUG {
            self.show();
            println!("|||||||||||@@@@");
        }
        let mut l = n;
        for _ in 0..self.h {
            self.field.remove(l);
            l += self.w as usize - 1;
        }
        self.w -= 1;
    }
    fn remove_row(&mut self, n: usize) {
        if DEBUG {
            self.show();
            println!("@@@@@@@@@@@@@@@");
        }
        for _ in 0..self.w {
            self.field.remove(n * self.w as usize);
        }
        self.h -= 1;
    }

    fn show(&self) {
        for y in 0..self.h as usize {
            let line: String = self.field[y * self.w as usize..(y + 1) * self.w as usize]
                .iter()
                .map(|&c| if c { '#' } else { '.' })
                .collect();
            println!("{}", line);
        }
    }
}

type Cell = bool;


let i=readLine()!.characters.split(" ").map{Int(String($0))!},H=i[0],W=i[1],a=(0..<H).map{_ in readLine()!.characters.map{String($0)}}
var r=(0..<H).map{_ in false},c=(0..<W).map{_ in false}
for i in 0..<H{for j in 0..<W{if a[i][j]=="#"{r[i]=true;c[j]=true}}}
for i in 0..<H{if r[i]{for j in 0..<W{if c[j]{print(a[i][j],terminator: "")}};print()}}


let input=readLine()!.characters.split(" ").map{Int(String($0))!}
let H=input[0],W=input[1]
let a=(0..<H).map{_ in readLine()!.characters.map{String($0)}}
var row=[Bool](count:H,repeatedValue:false)
var col=[Bool](count:W,repeatedValue:false)
for i in 0..<H{for j in 0..<W{if a[i][j]=="#"{row[i]=true;col[j]=true}}}
for i in 0..<H{if row[i]{for j in 0..<W{if col[j]{print(a[i][j],terminator: "")}};print()}}


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

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

let input = readIntSplit(by: " ")
let (H, W) = (input[0], input[1])
var a = [[String]](repeating: [""], count: H)
for i in 0..<H {
    a[i] = readLine()!.toArray()
}

var row = [Bool](repeating: false, count: H)
var col = [Bool](repeating: false, count: W)
for i in 0..<H {
    for j in 0..<W {
        if a[i][j] == "#" {
            row[i] = true
            col[j] = true
        }
    }
}

for i in 0..<H {
    if row[i] {
        for j in 0..<W {
            if col[j] {
                print(a[i][j], terminator: "")
            }
        }
        print()
    }
}


var i=readLine()!.characters.split(" ").map{Int(String($0))!},H=i[0],W=i[1],a=(0..<H).map{_ in readLine()!.characters.map{String($0)}},r=(0..<H).map{_ in 0},c=(0..<W).map{_ in 0}
for i in 0..<H{for j in 0..<W{if a[i][j]=="#"{r[i]=1;c[j]=1}}}
for i in 0..<H{if r[i]{for j in 0..<W{if c[j]{print(a[i][j],terminator: "")}};print()}}


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 objvs =(a)=>{const b=[];for(const v in a){b.push(a[v])}return b};
const main=()=>{
  let [h,w]=[tn(),tn()]
  let g=tss(h)

  for(let i=h-1;0<=i;i--){
    let c=true
    for(let j=w-1;0<=j;j--){
      if(g[i][j]!='.')c=false
    }
    if(c){
      g.splice(i,1)
      h--
    }
  }
  for(let j=w-1;0<=j;j--){
    let c=true
    for(let i=h-1;0<=i;i--){
      if(g[i][j]!='.')c=false
    }
    if(c){
      for(let i=h-1;0<=i;i--){
        let y = g[i].split('')
        y.splice(j,1)
        g[i]=y.join('')
      }
      w--
    }
  }
  for(let i=0;i<h;i++){
    to(g[i])
  }
}
main()


const stdin = require('fs').readFileSync('/dev/stdin', 'utf8')

const [h, w] = stdin
  .split('\n')[0]
  .split(' ')
  .map(Number)

const [, ...a] = stdin.trim().split('\n')

const aij = a.map(e => e.split(''))

let delRowIdx = []
let delColIdx = []

for (let i = 0; i < h; i++) {
  let rowStreak = true

  for (let j = 0; j < w; j++) {
    const el = aij[i][j]

    if (i === 0) {
      delColIdx.push(el === '#' ? false : true)
    } else if (el === '#') {
      delColIdx[j] = false
    }

    if (el === '#') {
      rowStreak = false
    }

    if (j === w - 1 && rowStreak) {
      delRowIdx.push(i)
    }
  }
}

for (let i = 0; i < h; i++) {
  if (delRowIdx.indexOf(i) === -1) {
    const row = aij[i].filter((r, j) => !delColIdx[j])
    console.log(row.join(''))
  }
}


import { readFileSync } from "fs";

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

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

  let field = input.slice(1, -1).map((line) => line[0]);

  field = field.filter((row) => !/^\.+$/.test(row));

  let count = 0;

  for (let j = 0; j < W; j++) {
    const cursor = j - count;

    if (field.every((row) => row[cursor] === ".")) {
      field = field.map(
        (row) => `${row.slice(0, cursor)}${row.slice(cursor + 1)}`
      );

      count += 1;
    }
  }

  return field.join("\n");
};

console.log(main(read()));


#include <bits/stdc++.h>
using namespace std;

int main()
{
  int h, w;
  cin >> h >> w;

  deque<string> rows;

  set<int> colIdxSet;

  for (int i = 0; i < h; i++)
  {
    string s;
    cin >> s;
    if (s.find('#') != string::npos)
    {
      for (int j = 0; j < s.size(); j++)
      {
        if (s[j] == '#')
        {
          colIdxSet.insert(j);
        }
      }
      rows.push_back(s);
    }
  }

  for (int i = 0; i < rows.size(); i++)
  {
    string row = rows[i];

    for (int j = 0; j < row.size(); j++)
    {
      if (colIdxSet.find(j) != colIdxSet.end())
      {
        cout << row[j];
      }
    }
    cout << endl;
  }

  return 0;
}


// yarn compile template.ts
{
	const process = (input: string[]) => {
		const h = parseInt(input[0].split(" ")[0])
		const w = parseInt(input[0].split(" ")[1])
		let b = input.filter((e, i) => i !== 0)

		let res = -1
		for (let i = 0; i < h; i++) {
			if (!/#/.test(b[i])) {
				res = i
				break
			}
		}
		if (res !== -1) {
			return b.filter((e, i) => i !== res).join("\n")
		}

		const c: string[][] = b.map((e) => e.split(""))
		let res2 = -1
		for (let j = 0; j < w; j++) {
			for (let i = 0; i < h; i++) {
				if (c[i][j] !== ".") {
					break
				}
				if (i === h - 1) {
					res = j
					break
				}
			}
			if (res !== -1) {
				break
			}
		}
		if (res !== -1) {
			return c.map((e) => e.filter((e, j) => j !== res).join("")).join("\n")
		}
		return b.join("\n")
	}

	const Main = (input: string): void => {
		//const num = parseInt(input)
		const ary = input.split("\n")
		console.log(process(ary))
	}
Main(require("fs").readFileSync("/dev/stdin", "utf8"))
}


// yarn compile template.ts
{
	const process = (input: string[]) => {
		const h = parseInt(input[0].split(" ")[0])
		const w = parseInt(input[0].split(" ")[1])
		let b = input.filter((e, i) => i !== 0)

		let res = -1
		for (let i = 0; i < h; i++) {
			if (!/#/.test(b[i])) {
				res = i
				break
			}
		}
		if (res !== -1) {
			return b.filter((e, i) => i !== res).join("\n")
		}

		const c: string[][] = b.map((e) => e.split(""))
		let res2 = -1
		for (let j = 0; j < w; j++) {
			for (let i = 0; i < h; i++) {
				if (c[i][j] !== ".") {
					break
				}
				if (i === h - 1) {
					res = j
					break
				}
			}
			if (res !== -1) {
				break
			}
		}
		if (res !== -1) {
			return c.map((e) => e.filter((e, j) => j !== res).join("")).join("\n")
		}
		return b.join("\n")
	}

	const Main = (input: string): void => {
		//const num = parseInt(input)
		const ary = input.split("\n")
		console.log(process(ary))
	}
/Main(require("fs").readFileSync("/dev/stdin", "utf8"))
}


K = int(input())
A,B = map(int, input().split())
check = 0
for i in range(A,B+1):
    if i%K == 0:
        print('OK')
        check = -1
        break
if check != -1:
    print('NG')


k=int(input())
a,b=map(int, input().split())
t=0
while t<a:
    t+=k
if t<=b:
    print('OK')
else:
    print('NG')


k= int(input())
a,b = map(int, input().split())

for i in range(a,b+1):
    if i % k ==0:
        print('OK')
        break
else:
    print('NG')


k=int(input())
a,b=map(int,input().split())

if a%k==0 or b%k==0:
  print("OK")
elif (a-b)==0 and k==1:
  print("OK")
elif (a-b)>=k:
  print("OK")
else:
  print("NG")


K = int(input())
A = int(input())
B = int(input())
""" K=4
A=5
B=7 """
q=0

for i in range(1,1000):
    if A <= i*K & i*K <= B:
        print("OK")
        q=1
        break

if q == 0:
    print("NG")


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

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;}
    public boolean hasNext() { while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++; 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() {
        long nl = nextLong();
        if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
        return (int) nl;
    }
    public double nextDouble() { return Double.parseDouble(next());}
}

public class Main {

	public static void main(String[] args) {
		// TODO 自動生成されたメソッド・スタブ

		FastScanner fs =  new FastScanner();

		int K = fs.nextInt();
		int A = fs.nextInt();
		int B = fs.nextInt();

		for(int i = A; i <= B; i++) {
			if(i % K == 0) {
				System.out.println("OK");
				return;
			}
		}
		System.out.println("NG");

	}

}


//master
import java.io.*;
import java.util.*;
public class Main {
    static int[][] memo;
    public static void main(String[] args) {
        FastScanner sc = new FastScanner();
        int n = sc.nextInt();
        int b = sc.nextInt();
        int c = sc.nextInt();
        for(int i = 1; i<=1000; i++) {
            int k = i*n;
            if(k>=b && k<=c) {
                p("OK");
                return;
            }
        }
        p("NG");
}

    public static <T> void p(T message) {
        System.out.println(message);
    }

    public static <T> void pe(T message) {
        System.err.println(message);
    }

    public static <T> void pp(T message) {
        System.out.print(message);
    }

}
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 boolean isPrintableChar(int c) {
        return 33 <= c && c <= 126;
    }

    public boolean hasNext() {
        while (hasNextByte() && !isPrintableChar(buffer[ptr]))
            ptr++;
        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() {
        long nl = nextLong();
        if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE)
            throw new NumberFormatException();
        return (int) nl;
    }

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


import java.math.BigInteger;
import java.util.*;
import java.io.*;

public class Main {

    public static void main(String[] args) throws Exception {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        int K = Integer.parseInt(in.readLine());
        String[] s = in.readLine().split(" ");
        int A = Integer.parseInt(s[0]);
        int B = Integer.parseInt(s[1]);
        if(A % K == 0) {
            System.out.println("OK");
        } else {
            int mod = A % K;
            int num = A + (K - mod);
            if(num <= B && num >= A) {
                System.out.println("OK");
            } else {
                System.out.println("NG");
            }
        }
    }
}


import java.io.*;
import java.util.*;

public class Main{

	static long mod=(long)1e9+7;

	public static void main(String[] args) throws IOException {
		Writer out=new Writer(System.out);
		Reader in=new Reader(System.in);
		int ts=1;

		outer: while(ts-->0) {
			long x=in.nextLong();
			long c=100;
			int i;
			for(i=1;;i++) {
				c=c+c/100;
				if(x<=c) break;
			}
			out.println(i);
		}
		out.close();

	}

	static boolean tri(int a, int b, int c) {
		if(c<a+b && c>abs(a-b)) return true;
		return false;
	}

/*********************************** UTILITY CODE BELOW **************************************/

	static int abs(int a) {
		return a>0 ? a : -a;
	}

	static int max(int a, int b) {
		return a>b ? a : b;
	}

	static int pow(int n, int m) {
		if(m==0) return 1;
		int temp=pow(n,m/2);
		long res=(((long)temp*temp)%mod);
		if(m%2==0) return (int)res;
		return (int)((res*n)%mod);
	}

	static class Pair{
		int u, v;

		Pair(int u, int v){this.u=u; this.v=v;}

		static void sort(Pair [] coll) {
			List<Pair> al=new ArrayList<>(Arrays.asList(coll));
			Collections.sort(al,new Comparator<Pair>() {
				public int compare(Pair p1, Pair p2) {
					return p1.u-p2.u;
				}
			});
			for(int i=0; i<al.size(); i++) {
				coll[i]=al.get(i);
			}
		}

	}

	static void sort(int[] a) {
		ArrayList<Integer> list=new ArrayList<>();
		for (int i:a) list.add(i);
		Collections.sort(list);
		for (int i=0; i<a.length; i++) a[i]=list.get(i);
	}

	static void sort(long a[]) {
		ArrayList<Long> list=new ArrayList<>();
		for(long i: a) list.add(i);
		Collections.sort(list);
		for(int i=0; i<a.length; i++) a[i]=list.get(i);
	}

	static int [] array(int n, int value) {
		int a[]=new int[n];
		for(int i=0; i<n; i++) a[i]=value;
		return a;
	}

	static class Reader{

		BufferedReader br;
		StringTokenizer to;

		Reader(InputStream stream){
			br=new BufferedReader(new InputStreamReader(stream));
			to=new StringTokenizer("");
		}

		String next() {
			while(!to.hasMoreTokens()) {
				try {
					to=new StringTokenizer(br.readLine());
				}catch(IOException e) {}

			}
			return to.nextToken();

		}

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

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

		int [] readArray(int n) {
			int a[]=new int[n];
			for(int i=0; i<n ;i++) a[i]=nextInt();
			return a;
		}
		long [] readLongArray(int n) {
			long a[]=new long[n];
			for(int i=0; i<n ;i++) a[i]=nextLong();
			return a;
		}

	}

	static class Writer extends PrintWriter{
		Writer(OutputStream stream){
			super(stream);
		}
		void println(int [] array) {
			for(int i=0; i<array.length; i++) {
				print(array[i]+" ");
			}
			println();
		}
		void println(long [] array) {
			for(int i=0; i<array.length; i++) {
				print(array[i]+" ");
			}
			println();
		}
	}

}


import java.util.*;
public class Main {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int k = sc.nextInt();
    int a = sc.nextInt();
    int b = sc.nextInt();
    System.out.println(((b - a + 1) >= k) ? "OK" : "NG");
  }
}


import java.util.Scanner;
public class Main {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int K = sc.nextInt();
    int A = sc.nextInt();
    int B = sc.nextInt();
    int flag = 0;
    for(int i = A; i<=B; i++){
            if(i%K == 0){
              flag++;
              break;
            }
    }
    if(flag==0){
      System.out.println("NG");
    }else if(flag==1){
      System.out.println("Yes");
    }
  }
}


#include <stdio.h>
#include <string.h>

int main(){
    int K,A,B;
    int a1,a2,b1,b2,i;

    scanf("%d", &K);
    scanf("%d %d", &A, &B);

    a1 = A / K;
    b1 = B / K;

    for(i = a1; i <= b1; i++){
        if ((A <= (i * K) && (i * K) <= B))
        {
            printf("OK");
            return 0;
        }
    }
    printf("NG");

    return 0;
}


#include <stdio.h>
int main(void) {
	int k, a ,b, i, flag=0;
	scanf("%d %d %d", &k, &a, &b);
	for(i=a; i<=b; i++){
		if(i%k==0){
			printf("OK");
			flag=1;
			break;
		}
	}
	if(flag==0)
		printf("NG");
	return 0;
}


#include<stdio.h>
int main()
{
	int k,a,b;
	int i;
	int sum=0;
	scanf("%d%d%d",&k,&a,&b);
	for(i=0;i<1000;i++)
	{
		sum+=k;
		//printf("sum=%d\n",sum);
		if(sum>=a&&sum<=b)
		{
			printf("OK\n");
			break;
		}
		if(sum>b)
		{
			printf("NG\n");
			break;
		}
	}

	return 0;
}


#include <bits/stdc++.h>
using namespace std;;
typedef long long ll;

int main(){
    ll x;
    cin >> x;
    ll money = 100;
    ll ans = 0;
    while(money<x){
        ans++;
        money += money/100;
    }
    cout << ans << endl;
}


#include<bits/stdc++.h>
using namespace std;
int main()
{
    int k,a,b;
    cin>>k>>a>>b;
    for(int i=a;i<=b;i++)
    if(i%k==0)
    {
    cout<<"OK"<<endl;
    break;
    }
    else
    {
    cout<<"NG"<<endl;
    break;
    }

    return 0;
}


#include <iostream>
#include <algorithm>
#include <bits/stdc++.h>
#define FAST ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
#define ll long long
#define mm(arr) memset(arr, 0, sizeof(arr))
#define scanArray(a,n) for(int i = 0; i < n; i++){cin >> a[i];}
#define pb push_back
#define PI 3.141592653589793
#define MOD 1000000007

using namespace std;
int main(){
    FAST
    int k,a,b; cin >> k >> a >> b;
    for(int i=a;i<=b;i++){
        if(i%a == 0){
            cout << "OK" << endl;
            return 0;
        }
    }
    cout << "NG" << endl;

    return 0;
}


#include<stdio.h>
int main()
{
	int k, a, b;
	scanf("%d%d%d", &k, &a, &b);
	if (a % k == 0 || b / k > a / k)
		printf("OK\n");
	else
		printf("NG\n");
	return 0;
}


#include <stdio.h>

int main(){
  int n, a, b;
  scanf("%d%d%d", &n, &a, &b);
  for(int i=a; i<=b; i++){
    if(i%n == 0){
      printf("OK\n");
      return 0;
    }
  }
  printf("NG\n");
  return 0;
}


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

int main()
{
	int K;
	int A, B;
	scanf("%d", &K);
	scanf("%d %d", &A, &B);

	int r;
	int c = 0;
	for(r=A; r<=B; r++){
		if(r % K == 0){
			c = 1;
			break;
		}
	}

	if(c == 0) printf("NG");
	else printf("OK");

	return 0;

}


#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#include<time.h>
#define FOR(i,n) for(int i=0;i<n;i++)
#define PRN(n) printf("%d\n",n)
#define PRF(n) printf("%lf\n",n)
#define PRL(n) printf("%lld\n",n)
#define PRS(s) printf("%s\n",s)
#define PRC(c) printf("%c",c)
#define INI(n) scanf("%d",&n)
#define INL(n) scanf("%lld",&n)
#define INF 10000000000
#define mod 1000000007
#define X 100000
#define N 20
#define M 46
typedef long long int ll;
ll finv[X];
ll fac[X];
ll inv[X];
ll usort(const void *a, const void *b){return *(ll*)a-*(ll*)b;}
ll dsort(const void *a, const void *b){return *(ll*)b-*(ll*)a;}
ll ssort(const void *a, const void *b){return strcmp((char*)a,(char*)b);}
void Iswap(int *a,int *b){
  int t=*a;
  *a=*b;
  *b=t;
}
void Fswap(double *a,double *b){
  double t=*a;
  *a=*b;
  *b=t;
}
void Lswap(ll *a,ll *b){
  ll t=*a;
  *a=*b;
  *b=t;
}
ll min(ll a,ll b){
  if(a>b)return b;
  return a;
}
ll max(ll a,ll b){
  if(a>b)return a;
  return b;
}
ll z(ll a){return max(a,-a);}
ll gcd(ll a,ll b){if(!b){return a;}else{return gcd(b,a%b);}}
ll lcm(ll a,ll b){return a*b/gcd(a,b);}
ll kt(ll a){
  ll sum=0;
  while(a){
    a/=10;
    sum++;
  }
  return sum;
}
ll ks(ll a){
  ll sum=0;
  while(a){
    sum+=a%10;
    a/=10;
  }
  return sum;
}
void nCrReady(){
  fac[0]=fac[1]=1;
  finv[0]=finv[1]=1;
  inv[1]=1;
  for (ll i=2;i<X;i++){
    fac[i]=fac[i-1]*i%mod;
    inv[i]=mod-inv[mod%i]*(mod/i)%mod;
    finv[i]=finv[i-1]*inv[i]%mod;
  }
}
ll nCr(ll n,ll k){return fac[n]*(finv[k]*finv[n-k]%mod)%mod;}
ll modpow(ll a,ll n){
  ll res=1;
  while(n>0){
    if(n&1)res=res*a%mod;
    a=a*a%mod;
    n>>=1;
  }
  return res;
}
int main(void){
  int k;
  INI(k);
  int a;
  INI(a);
  int b;
  INI(b);
  for(int i=a;i<b+1;i++){
    if(i%k<1){
      PRS("Yes");
      return 0;
    }
  }
  PRS("No");
  return 0;
}


#include <stdio.h>

int main()
{
	int k;
	int a;
	int b;

	scanf("%d", &k);
	scanf("%d %d", &a, &b);
	while (a < b)
	{
		if (a % k == 0)
		{
			printf("OK\n");
			return;
		}
		a++;
	}
	printf("NG\n");
  	return;
}


#include <stdio.h>

int main()
{
	int k;
	int a;
	int b;

	scanf("%d", &k);
	scanf("%d %d", &a, &b);
	while (a < b)
	{
		if (a % k == 0)
		{
			printf("OK");
			return;
		}
		a++;
	}
	printf("NG");
  	return;
}


function Main(input){
  input = input.split('\n').map(x=>x.split(' ').map(y=>parseInt(y)));
  var ans = 'NG';
  for (i=input[1][0];i<=input[1][1];i++){
    if (i%input[0][0] == 0){
      ans = 'OK';
      break;
    }
  }
  console.log(ans);
}

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


const main = (inputs) => {
  var array = inputs[0].split(" ");
  var array2 = inputs[1].split(" ");

  var K = Number(array);
  var A = Number(array2[0]);
  var B = Number(array2[1]);

  var num = K * Math.floor(B / K)

  if (num >= A && num <= B) {
    console.log('OK');
  } else {
    console.log('NG');
  }

}
main(require('fs').readFileSync('/dev/stdin', 'UTF-8').trim().split("\n"));


// inputに入力データ全体が入る
function Main(input) {
// 1行目がinput[0], 2行目がinput[1], …に入る
　input = input.split("\n");
  k = ~~input[0]
　a = ~~input[1].split(" ")[0];
  b = ~~input[1].split(" ")[1];
  let i=k;
  while (i <= b){
    if(i >= a && i <= b ){
      console.log("OK");
      return;
    }
    i += k;
  }
  console.log("NG")
  return;
}
//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));


const main = (input) => {
    input = input.split('\n');
    const K = input[0];
    const tmp = input[1].split(' ');
    const A = tmp[0];
    const B = tmp[1];

    for (let i = A; i <= B; i++) {
        if (i % K === 0) {
            console.log('OK');
            return;
        }
    }

    console.log('NG');
};

// 標準入力
main(require('fs').readFileSync('/dev/stdin', 'utf8'));


function main(input) {
  input = input.split('\n');
  const first = BigInt(input[0]);

  let year = 0;
  let stock = BigInt(100);
  while (stock < first) {
    stock = BigInt(Math.trunc(Number(stock) * 1.01))
    // if (stock >= first) {
    //   console.log(year)
    //   break
    // }

    year++;
  }
  console.log(year)
}

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


"use strict"
const create = () => {
    const input = require("fs").readFileSync("/dev/stdin", "utf8").trim().split("\n");
    const res = {
        "list": input, "index": 0, "max": input.length,
        "hasNext": function() {return this.index < this.max},
        "next": function() { if (!this.hasNext()) {throw "ArrayIndexOutOfBoundsException";}else{return this.list[this.index++];}}
    };
    return res;
}
const o = create();
const next = () => o.next()
const nextInt = () => parseInt(o.next())
const nextStrArray = () => o.next().split(" ")
const nextIntArray = () => o.next().split(" ").map(el => parseInt(el))
const nextCharArray = () => o.next().split("")
const hasNext = () => o.hasNext()
const myout = (...x) => console.log(...x)
const Main = () => {
    const K = nextInt()
    const [A, B] = nextIntArray()
    let tmp = 0
    while(tmp<=B){
        tmp = tmp + K
        if(A <= tmp && tmp <=B) console.log("OK")
    }
    console.log("NG")
}
Main()


package main

import (
	"fmt"
)

func main() {
	var k, a, b int
	fmt.Scanf("%d\n%d %d", &k, &a, &b)
	for i := a; i <= b; i++ {
		if i%k == 0 {
			fmt.Println("OK")
			return
		}
	}
	fmt.Println("NG")
}


package main

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

func main() {
	io := NewIo()
	defer io.Flush()

	// AUTOGENERATE

	// STR := io.Next()
	// Log("string", STR)

	// F := io.NextFloat()
	// Log("float", F)

	// parsing int array
	N := io.NextInt()
	Logf("%v\n", N)
	A := io.NextInt()
	Logf("%v\n", A)
	B := io.NextInt()
	Logf("%v\n", B)

	for i := A; i <= B; i++ {
		if i%N == 0 {
			fmt.Printf("OK\n")
			os.Exit(0)
		}
	}
	fmt.Printf("NG\n")
	// var A [200000]int
	// for i := 0 ; i < N; i++ {
	// 	A[i] = io.NextInt()
	// }
	// Logf("A %v\n", A[0:10])
	// sort.Sort(sort.Reverse(sort.IntSlice(A[:])))
	// sort.Sort(sort.IntSlice(A[:]))

	// parsing string as byte array
	// var s [10000]byte
	// str := io.Next()
	// for i := 0; i < len(str); i++ {
	// 	s[i] = str[i]
	// }
	// Log("byte array", s[0:10])

	// fmt.Printf("%d %d %d\n", N, M, intMax(N, M))
	// fmt.Printf("Lucas %d %d\n", combMod(N, M, 13), combination(N, M))

	// write your own code here

}

// Libraries

type Io struct {
	reader    *bufio.Reader
	writer    *bufio.Writer
	tokens    []string
	nextToken int
}

// NewIo
func NewIo() *Io {
	return &Io{
		reader: bufio.NewReader(os.Stdin),
		writer: bufio.NewWriter(os.Stdout),
	}
}

// Flush
func (io *Io) Flush() {
	err := io.writer.Flush()
	if err != nil {
		panic(err)
	}
}

// NextLine
func (io *Io) NextLine() string {
	var buffer []byte
	for {
		line, isPrefix, err := io.reader.ReadLine()
		if err != nil {
			panic(err)
		}
		buffer = append(buffer, line...)
		if !isPrefix {
			break
		}
	}
	return string(buffer)
}

// Next
func (io *Io) Next() string {
	for io.nextToken >= len(io.tokens) {
		line := io.NextLine()
		io.tokens = strings.Fields(line)
		io.nextToken = 0
	}
	r := io.tokens[io.nextToken]
	io.nextToken++
	return r
}

// NextInt
func (io *Io) NextInt() int {
	i, err := strconv.Atoi(io.Next())
	if err != nil {
		panic(err)
	}
	return i
}

// NextFloat
func (io *Io) NextFloat() float64 {
	i, err := strconv.ParseFloat(io.Next(), 64)
	if err != nil {
		panic(err)
	}
	return i
}

// PrintLn
func (io *Io) PrintLn(a ...interface{}) {
	fmt.Fprintln(io.writer, a...)
}

// Printf
func (io *Io) Printf(format string, a ...interface{}) {
	fmt.Fprintf(io.writer, format, a...)
}

// PrintIntLn
func (io *Io) PrintIntLn(a []int) {
	b := []interface{}{}
	for _, x := range a {
		b = append(b, x)
	}
	io.PrintLn(b...)
}

// PrintStringLn
func (io *Io) PrintStringLn(a []string) {
	b := []interface{}{}
	for _, x := range a {
		b = append(b, x)
	}
	io.PrintLn(b...)
}

// Log
func Log(name string, value interface{}) {
	fmt.Fprintf(os.Stderr, "%s=%+v\n", name, value)
}

// Log format for standard error output
func Logf(format string, a ...interface{}) {
	fmt.Fprintf(os.Stderr, format, a...)
}

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

func intMax(a, b int) int {
	if a > b {
		return a
	}
	return b
}

// direct calculation of combination
// n, m should be "small"
func combination(n, m int) int {
	if m > n {
		return 0
	} else if m == n || m == 0 {
		return 1
	} else {
		res := 1
		for i := 0; i < m; i++ {
			res *= (n - i)
		}
		for i := 1; i <= m; i++ {
			res /= i
		}
		return res
	}
}

// caluclate combination modulo based on Lucas theorem
func lucas(n, m, p int) int {
	ntemp := n
	mtemp := m
	res := 1
	for i := 0; i < 100; i++ {
		// fmt.Printf("ntemp: %d\n", ntemp)
		nreminder := ntemp % p
		ntemp = ntemp / p
		mreminder := mtemp % p
		mtemp = mtemp / p
		res = res * (combination(nreminder, mreminder) % p)
		if ntemp == 0 {
			break
		}
	}
	return res % p
}

func combMod(n, m, p int) int {
	return lucas(n, m, p)
}

// BFS/DFS
//
// visited := []int{}
// dfs(1, neighbor, func(node int) {
// 	visited = append(visited, node)
// })
// fmt.Println(visited)

func bfs(start int, nodes map[int][]int, fn func(int)) {
	frontier := []int{start}
	visited := map[int]bool{}
	next := []int{}

	for 0 < len(frontier) {
		next = []int{}
		for _, node := range frontier {
			visited[node] = true
			fn(node)
			for _, n := range bfs_frontier(node, nodes, visited) {
				next = append(next, n)
			}
		}
		frontier = next
	}
}

func bfs_frontier(node int, nodes map[int][]int, visited map[int]bool) []int {
	next := []int{}
	iter := func(n int) bool { _, ok := visited[n]; return !ok }
	for _, n := range nodes[node] {
		if iter(n) {
			next = append(next, n)
		}
	}
	return next
}

func dfs(node int, nodes map[int][]int, fn func(int)) {
	dfs_recur(node, nodes, map[int]bool{}, fn)
}

func dfs_recur(node int, nodes map[int][]int, v map[int]bool, fn func(int)) {
	v[node] = true
	fn(node)
	for _, n := range nodes[node] {
		if _, ok := v[n]; !ok {
			dfs_recur(n, nodes, v, fn)
		}
	}
}

// handles 2 function, one is before entering child tree, and another is
// after entering child tree.
func dfs2(node int, nodes map[int][]int, fn1, fn2 func(int, int)) {
	dfs2_recur(node, -1, nodes, map[int]bool{}, fn1, fn2)
}

func dfs2_recur(node, parent int, nodes map[int][]int, v map[int]bool, fn1, fn2 func(int, int)) {
	v[node] = true
	fn1(node, parent)
	for _, n := range nodes[node] {
		if _, ok := v[n]; !ok {
			dfs2_recur(n, node, nodes, v, fn1, fn2)
		}
	}
	fn2(node, parent)
}

// Stack data structure
type Stack struct {
	top  *Element
	size int
}

type Element struct {
	value interface{}
	next  *Element
}

func (s *Stack) Len() int {
	return s.size
}

func (s *Stack) Push(value interface{}) {
	s.top = &Element{value, s.top}
	s.size++
}

func (s *Stack) Pop() (value interface{}) {
	if s.size > 0 {
		value, s.top = s.top.value, s.top.next
		s.size--
		return
	}
	return nil
}

// powerInt (use math.Pow() for float parameters)
func powerInt(n, p int) int {
	tmp := 1
	for i := 0; i < n; i++ {
		tmp *= p
	}
	return tmp
}

func findDivisors(n int, a *[]int) {
	if n == 1 {
		return
	}

	sqrt := int(math.Sqrt(float64(n)))
	for i := 2; i <= sqrt; i++ {
		if n%i == 0 {
			*a = append(*a, i)
			*a = append(*a, n/i)
		}
	}
	*a = append(*a, n)
}

func removeDuplicate(a []int) []int {
	m := make(map[int]bool)
	for i := 0; i < len(a); i++ {
		m[a[i]] = true
	}
	res := []int{}
	for i, _ := range m {
		res = append(res, i)
	}
	return res
}

// var gcdmap map[int](map[int]int)
// func gcd(a, b int) int {
// 	ina := a
// 	inb := b
// 	if _, ok := gcdmap[a]; !ok {
// 		gcdmap[a] = make(map[int]int)
// 	}
// 	if _, ok := gcdmap[ina][inb]; ok {
// 		return gcdmap[ina][inb]
// 	}
// 	for b != 0 {
// 		t := b
// 		b = a % b
// 		a = t
// 	}
// 	gcdmap[ina][inb] = a
// 	return a
// }


package main

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

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	const initialBufSize = 4096
	const maxBufSize = 1000000
	scanner.Buffer(make([]byte, initialBufSize), maxBufSize)
	scanner.Split(bufio.ScanWords)
	var K int64
	scanner.Scan()
	K, _ = strconv.ParseInt(scanner.Text(), 10, 64)
	var A int64
	scanner.Scan()
	A, _ = strconv.ParseInt(scanner.Text(), 10, 64)
	var B int64
	scanner.Scan()
	B, _ = strconv.ParseInt(scanner.Text(), 10, 64)
	fmt.Println(solve(K, A, B))
}
func solve(K int64, A int64, B int64) string {
	for i := A; i <= B; i++ {
		if i%K == 0 {
			return "OK"
		}
	}
	return "NG"
}


package main

import (
  "fmt"
)

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

  ans := "NG"
  if a % k == 0 {
    ans = "Yes"
  }
  if (a/k) < (b/k) {
    ans = "Yes"
  }
  fmt.Printf("%s\n", ans)
}


package main

import "fmt"

func main() {
	var k, a, b int
	fmt.Scan(&k, &a, &b)
	if a%k == 0 || b%k == 0 {
		fmt.Println("OK")
		return
	}

	if b-a >= k {
		fmt.Println("OK")
		return
	}

	fmt.Println("NG")
}


package main

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

const mod = 998244353
const facNum = 300001

func main() {
	sc := newScanner(os.Stdin)
	K, A, B := sc.i(), sc.i(), sc.i()
	for i := A; i <= B; B ++ {
		if i % K == 0 {
			fmt.Println("OK")
			return
		}
	}
	fmt.Println("NG")

	//if K > A {
	//	fmt.Println("NG")
	//	return
	//}
	//m := A % K
	//if m == 0 {
	//	fmt.Println("OK")
	//	return
	//}
	//da := A / K
	//db := B / K
	//if db > da {
	//	fmt.Println("OK")
	//} else {
	//	fmt.Println("NG")
	//}

}

// fmt.Println("Yes")
// fmt.Println("No")

// I/O
type scanner struct {
	sc *bufio.Scanner
}

func newScanner(input io.Reader) *scanner {
	sc := bufio.NewScanner(input)
	sc.Split(bufio.ScanWords)
	sc.Buffer(make([]byte, 1024), int(1e+9))
	return &scanner{sc}
}

func (s *scanner) s() string {
	s.sc.Scan()
	return s.sc.Text()
}

func (s *scanner) i() int {
	i, e := strconv.Atoi(s.s())
	if e != nil {
		panic(e)
	}
	return i
}

func (s *scanner) f() float64 {
	f, e := strconv.ParseFloat(s.s(), 64)
	if e != nil {
		panic(e)
	}
	return f
}

func (s *scanner) bs() []byte {
	return []byte(s.s())
}

func (s *scanner) is(n int) []int {
	res := make([]int, n)
	for i := 0; i < n; i++ {
		res[i] = s.i()
	}
	return res
}

func (s *scanner) fs(n int) []float64 {
	res := make([]float64, n)
	for i := 0; i < n; i++ {
		res[i] = s.f()
	}
	return res
}

//const factorial = new
func Pow(a, n int) int {
	ans := 1
	for n > 0 {
		if (n & 1) == 1 {
			ans = ans * a % mod
		}
		a = a * a % mod
		n = n >> 1
	}
	return ans
}

func Gcd(a, b int) int {
	if a < b {
		return Gcd(b, a)
	}
	for b != 0 {
		a, b = b, a%b
	}
	return a
}

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

func combination(n, k int, fac, ifac []int) int {
	if n < k || n < 0 {
		return 0
	}
	if k == 0 {
		return 1
	}
	//while n != 0
	ans := ifac[k] * ifac[n-k] % mod
	return ans * fac[n] % mod
}

// 階乗: factorial
// コンビネーションを計算する際に前もって計算しておく
// fac[k] => k! (mod M)
// ifac[k] => k!^(M-2) (mod M)
// n: ex. 2 * 10^5 => 200001
// fac, ifac := factorial()
func factorial() (fac []int, ifac []int) {
	fac = make([]int, facNum)
	fac[0] = 1
	ifac = make([]int, facNum)
	ifac[0] = 1
	for i := 1; i < facNum; i++ {
		fac[i] = fac[i-1] * i % mod
		ifac[i] = ifac[i-1] * Pow(i, mod-2) % mod
	}
	return
}


K = gets.to_i
A, B = gets.split.map(&:to_i)

A.upto(B) do |i|
    if i % K == 0 then
        puts 'OK'
        exit
    end
end
puts 'NG'


k = gets.to_i
a, b = gets.split("\s").map(&:to_i)
able = false

1.upto(b) do |i|
  if k * i >= a && b >= k * i
    print 'OK'
    able = true
    break
  end
  if k * i > b
    break
  end
end

print 'NG' unless able


k=gets.to_i
a,b=gets.split.map(&:to_i)
i=0
a.upto(b){|n|
  if n%k==0
    puts "OK"
    i=1
    break
  end
  }

puts i==0? "NG" : ""


a,b,c=`dd`.split.map(&:to_i)
(b..c).each{|i|if i%a==0
  puts 'OK'
  exit}
puts 'NG'


a=gets.chomp
m=100
c=0
while a>m
 m+=m/100
 c+=1
end
p c


x=gets.to_i
c=0
m=100
while x>=m do
m+=(m*0.01).floor
c+=1
end
p c


// -*- coding:utf-8-unix -*-

use proconio::input;

// ABC086C - Traveling
// https://atcoder.jp/contests/abs/fasks/arc089_a
fn main() {
    input! {
        k: usize,
        a: usize,
        b: usize,
    }
    let mut ans = false;
    if a % k == 0 || b % k == 0 {
        ans = true;
    } else if b - a >= k {
        ans = true;
    } else if a % k > b % k {
        ans = true;
    }

    if ans == true {
        println!("OK");
    } else {
        println!("NG");
    }
}


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

  ($next:expr, mut $var:ident : $t:tt $($r:tt)*) => {
    let mut $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")
  };
}

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

#[cfg(not(debug_assertions))]
macro_rules! mydbg {
    ($($arg:expr),*) => {};
}

macro_rules! echo {
    ($($a:expr),*) => {
          $(println!("{}",$a))*
      }
}

use std::cmp::Ordering::*;
#[allow(unused_imports)]
use std::cmp::{max, min};
use std::collections::{HashMap, HashSet, VecDeque};
use std::io::{stdout, BufWriter, Write};
use std::mem::swap;

fn main() {
    input! {
        k: i32,
        a: i32,
        b: i32,
    }
    let mut is_possible = false;
    'calc: for v in a..b + 1 {
        if v % k == 0 {
            is_possible = true;
            break 'calc;
        }
    }
    if is_possible {
        echo!("OK");
    } else {
        echo!("NG");
    }
}


use proconio::{
   fastout, input,
   marker::{Bytes, Chars, Isize1, Usize1},
};

fn main() {
   input! {
      k:usize,
      a:usize,b:usize
   }

   for i in a..=b {
      if i % k == 0 {
         println!("OK");
         return;
      }
   }
   println!("NG");
}


macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let mut s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

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

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

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

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

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

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

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

fn main() {
    input! {k: i32, a: i32, b: i32};

    let x = k - a % k + a;

    if b >= x || k == 1 {
        println!("OK")
    } else if a == b && a % k == 0 {
        println!("OK")
    } else {
        println!("NG")
    }
}


macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let mut s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

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

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

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

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

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

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

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

fn main() {
    input! {k: i32, a: i32, b: i32};

    let x = a % k;

    if b - a + x >= k || k == 1 {
        println!("OK")
    } else if a == b && a % k == 0 {
        println!("OK")
    } else {
        println!("NG")
    }
}


macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let mut s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

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

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

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

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

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

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

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

fn main() {
    input! {k: u64, a: u64, b: u64};

    let x = a % k;

    if b - a + x >= k || k == 1 {
        println!("OK")
    } else if a == b && a % k == 0 {
        println!("OK")
    } else {
        println!("NG")
    }
}


let aa = Int(readLine()!)!
let arr=readLine()!.split{$0==" "}.map{Int(String($0))!}
var a=arr[0]
var b=arr[1]
var i = 0
while a <= b {
    if a%aa == 0 {
        print("OK")
        i = 1
        break
    }
    a+=1
}
if i == 0 {
    print("NG")
}


func main() {
  let k = Int(readLine()!)!
  let ab = readLine()!.split(separator: " ").map { Int($0)! }
  let (a, b) = (ab[0], ab[1])

  for i in a...b {
    if i % k == 0 {
      print("OK")
      return
    }
  }

  print("NG")
  return
}

main()


let k = Int(readLine()!)!
let i = readLine()!
    .split(separator: " ")
    .map { Int($0)! }
let (a, b) = (i[0], i[1])
let x = (a...b).contains { $0.isMultiple(of: k) }
let y = (a == b) && (a == k)
print(x || y ? "OK" : "NG")


import Foundation

let input_line: String = readLine()!
let split: [String] = input_line.components(separatedBy: " ")

let K = Int(split[0])!
let A = Int(split[1])!
let B = Int(split[2])!

if (B - B % K >= A){
    print("OK")
}else{
    print("NG")
}


let k = cin.n
let (a,b) = cin.pair

if b%k == 0 || a%k == 0 || b-k >= a {
  print("OK")
} else {
  print("NG")
}

import Foundation
#if os(Linux)
    import Glibc
#else
    import Darwin.C
#endif

enum cin {
    // 123
    static var n: Int { Int(readLine()!)! }
    // 12 23
    static var pair: (Int, Int) { let line = readLine()!.components(separatedBy: " "); return (Int(line[0])!, Int(line[1])!) }
    // 12 23 34
    static var triple: (Int, Int, Int) { let line = readLine()!.components(separatedBy: " "); return (Int(line[0])!, Int(line[1])!, Int(line[2])!) }
    // AtCoder
    static var line: String { readLine()! }
    // At Coder
    static var arrayStr: [String] { line.components(separatedBy: " ") }
    // 1 2 3 4
    static var array: [Int] { line.components(separatedBy: " ").map { Int($0)! } }
    // 1
    // 2
    // 3
    static func v_array(count: Int) -> [Int] { (0..<count).map { _ in n } }
}

extension Int {
    // 123 -> [1, 2, 3]
    var digits: [Int] { Array(String(self)).map { Int(String($0))! } }
}

extension Array where Element == Int {
    // [2, 1, 3, 2] -> 8
    var sum: Int { self.reduce(0, +) }
    // [2, 1, 3, 2] -> [1, 2, 2, 3]
    var orderBy: [Int] { sorted() }
    // [2, 1, 3, 2] -> [3, 2, 2, 1]
    var orderByDesc: [Int] { sorted(by: { $0 > $1 }) }
    // [2, 1, 3, 2] -> [2, 1, 3]
    var distinct: [Int] { Array(Set(self)) }
}

extension String {
    // e.g. cin.line.regex(match: "^(dream|dreamer|erase|eraser)*$")
    func regex(match pattern: String) -> Bool {
        let regex = try! NSRegularExpression(pattern: pattern)
        return regex.firstMatch(in: self, range: NSRange(location: 0, length: self.count)) != nil
    }
    // "ABC"[1] -> "B"
    subscript(i: Int) -> Character {
        get {
            self[index(at: i)]
        }
        set(char) {
            var characters = Array(self)
            characters[i] = char
            self = String(characters)
        }
    }
    func index(at offset: Int) -> String.Index { index(startIndex, offsetBy: offset) }
    // "ABC".swapAt(0, 1) -> "BAC"
    mutating func swapAt(_ index1: Int, _ index2: Int) {
        var characters = Array(self)
        characters.swapAt(index1, index2)
        self = String(characters)
    }
}


let k = cin.n
let (a,b) = cin.pair

if b%k == 0 || b-k >= a {
  print("OK")
} else {
  print("NG")
}

import Foundation
#if os(Linux)
    import Glibc
#else
    import Darwin.C
#endif

enum cin {
    // 123
    static var n: Int { Int(readLine()!)! }
    // 12 23
    static var pair: (Int, Int) { let line = readLine()!.components(separatedBy: " "); return (Int(line[0])!, Int(line[1])!) }
    // 12 23 34
    static var triple: (Int, Int, Int) { let line = readLine()!.components(separatedBy: " "); return (Int(line[0])!, Int(line[1])!, Int(line[2])!) }
    // AtCoder
    static var line: String { readLine()! }
    // At Coder
    static var arrayStr: [String] { line.components(separatedBy: " ") }
    // 1 2 3 4
    static var array: [Int] { line.components(separatedBy: " ").map { Int($0)! } }
    // 1
    // 2
    // 3
    static func v_array(count: Int) -> [Int] { (0..<count).map { _ in n } }
}

extension Int {
    // 123 -> [1, 2, 3]
    var digits: [Int] { Array(String(self)).map { Int(String($0))! } }
}

extension Array where Element == Int {
    // [2, 1, 3, 2] -> 8
    var sum: Int { self.reduce(0, +) }
    // [2, 1, 3, 2] -> [1, 2, 2, 3]
    var orderBy: [Int] { sorted() }
    // [2, 1, 3, 2] -> [3, 2, 2, 1]
    var orderByDesc: [Int] { sorted(by: { $0 > $1 }) }
    // [2, 1, 3, 2] -> [2, 1, 3]
    var distinct: [Int] { Array(Set(self)) }
}

extension String {
    // e.g. cin.line.regex(match: "^(dream|dreamer|erase|eraser)*$")
    func regex(match pattern: String) -> Bool {
        let regex = try! NSRegularExpression(pattern: pattern)
        return regex.firstMatch(in: self, range: NSRange(location: 0, length: self.count)) != nil
    }
    // "ABC"[1] -> "B"
    subscript(i: Int) -> Character {
        get {
            self[index(at: i)]
        }
        set(char) {
            var characters = Array(self)
            characters[i] = char
            self = String(characters)
        }
    }
    func index(at offset: Int) -> String.Index { index(startIndex, offsetBy: offset) }
    // "ABC".swapAt(0, 1) -> "BAC"
    mutating func swapAt(_ index1: Int, _ index2: Int) {
        var characters = Array(self)
        characters.swapAt(index1, index2)
        self = String(characters)
    }
}


// inputに入力データ全体が入る
function Main(input) {
	input = input.split("\n");
	rangeLineString = input[1].split(" ");
	//入力値を取得
	var k = parseInt(input[0], 10);
	var a = parseInt(rangeLineString[0], 10);
	var b = parseInt(rangeLineString[1], 10);
	var canClear = false;
  	//割り切れるかチェック
  	for(a; a <= b; a++){
      if(a % k == 0){
        canClear = true;
      }
    }
  	//出力
  	if(canClear){
      console.log('OK');
    }else{
      console.log('NG');
    }
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));


import * as fs from "fs";

const input = (fs.readFileSync("/dev/stdin", "utf8") as string).split("\n");
const k = +input[0];
const [a, b] = input[1].split(" ").map((x: string): number => +x);

let result = false;
for (let i = a; i <= b; i++) {
	if (i % k === 0) result = true;
}

console.log(result ? "OK" : "NG");


import * as fs from 'fs';

export function Main(input: string) {
    const lines = input.split('\n');    // ?
    const k = parseInt(lines[0]);   // ?
    const [a, b] = lines[1].split(' ').map(int => parseInt(int));   // ?

    let result = 'NG';
    for (let i = ~~(a / k) * k; i <= b; i += k) {
        if (i >= a) {
            result = 'OK';
            break;
        }
    }

    //output

    console.log(result);
}

// Don't edit this line!
Main(fs.readFileSync("/dev/stdin", "utf8"));


import * as fs from 'fs';

// main
function main(input: string[]) {
    // param
    var k: number = 0;
    var a: number = 0;
    var b: number = 0;
    var ans: string = "";
    // init
    k = Number(input.shift());
    [a, b] = input.shift().split(" ").map(x => Number(x));
    // solve
    ans = "NG";
    for (var kx = 0; kx < 1000; kx += k) {
        if (a <= kx && kx <= b) {
            ans = "OK";
            break;
        }
    }
    // answer
    console.log(ans);
}

// graph lib
/*
function GRAPH_enumPattern(cur: number[], pat: number[][]): number[][] {
    var arr = [];
    for (var patx = 0; patx < pat.length; patx++) {
        var pos = [cur[0] + pat[patx][0], cur[1] + pat[patx][1]];
        arr.push(pos);
    }
    return arr;
}
*/

// math lib
/*
function Math_max(arr: number[]): number { return arr.reduce((x, y) => Math.max(x, y)); }
function Math_min(arr: number[]): number { return arr.reduce((x, y) => Math.min(x, y)); }
function Math_gcd(): number {
    var ans = arguments[0];
    var f = (a: number, b: number): number => b ? f(b, a % b) : a
    for (var i = 1; i < arguments.length; i++) {
        ans = f(ans, arguments[i]);
    }
    return ans
};
function Math_gcdArray(values: number[]): number {
    var ans = values[0];
    var f = (a: number, b: number): number => b ? f(b, a % b) : a
    for (var i = 1; i < values.length; i++) {
        ans = f(ans, values[i]);
    }
    return ans
};
function Math_lcm(): number {
    var a = arguments
    var g = (n: number, m: number): number => m ? g(m, n % m) : n
    var l = (n: number, m: number): number => n * m / g(n, m)
    var ans = a[0]
    for (var i = 1; i < a.length; i++) {
        ans = l(ans, a[i])
    }
    return ans
}
function Math_lcmArray(values: number[]): number {
    var a = values
    var g = (n: number, m: number): number => m ? g(m, n % m) : n
    var l = (n: number, m: number): number => n * m / g(n, m)
    var ans = a[0]
    for (var i = 1; i < a.length; i++) {
        ans = l(ans, a[i])
    }
    return ans
}
function Math_primeList(value: number): number[] {
    var ans = [];
    var arr = new Array(value).fill(0);
    for (var i = 2; i < value; i++) {
        if (arr[i] == 0) {
            for (var j = i; j < value; j += i) {
                if (arr[j] == 0) arr[j] = i;
            }
        }
    }
    for (var i = 2; i < value; i++) {
        if (arr[i] == i) ans.push(i);
    }
    return ans;
}
function Math_primeFactor(p: number[], value: number): number[][] {
    var ans: number[][] = [];
    var valmax = value / 2;;
    for (var i = 0; i < p.length; i++) {
        var prime = p[i];
        if (valmax < prime) break;
        var count = 0;
        while (value % prime == 0) {
            value /= prime;
            count++;
        }
        if (count != 0) {
            ans.push([prime, count]);
        }
        if (value == 1) break;
    }
    return ans;
}
*/

// union-find lib
/*
var g_uf_root: number[];
var g_uf_count: number[];
function UF_initRoot(num: number) {
    g_uf_root = new Array(num).fill(-1);
    g_uf_count = new Array(num).fill(1);
}
function UF_getRoot(index: number) {
    if (g_uf_root[index] < 0) {
        return index;
    } else {
        var work0: number = UF_getRoot(g_uf_root[index]);
        g_uf_root[index] = work0;
        return work0
    }
}
function UF_mergeRoot(a: number, b: number) {
    var root0: number = UF_getRoot(a);
    var root1: number = UF_getRoot(b);
    if (root0 == root1) return;
    if (root0 > root1) [root0, root1] = [root1, root0];
    g_uf_count[root0] += g_uf_count[root1];
    g_uf_count[root1] = 0;
    g_uf_root[root1] = root0;
}
*/

// entrypoint
function entrypoint() {
    try {
        // linux
        var input = fs.readFileSync("/dev/stdin", "utf8").trim().split("\n");
        console.debug = function () { };
        main(input);
    }
    catch (ex) {
        // windows
        const lines: string[] = [];
        // @ts-ignore
        const reader = require('readline').createInterface({
            // @ts-ignore
            input: process.stdin,
            // @ts-ignore
            output: process.stdout
        });
        reader.on('line', function (line: string) {
            lines.push(line);
        });
        reader.on('close', function () {
            input = lines;
            main(input);
        });
    }
}
entrypoint();


import * as fs from 'fs';

// main
function main(input: string[]) {
    // param
    var k: number = 0;
    var a: number = 0;
    var b: number = 0;
    var ans: string = "";
    // init
    k = Number(input.shift());
    [a, b] = input.shift().split(" ").map(x => Number(x));
    // solve
    if (b < k) {
        ans = "NG"
    } else if (Math.floor(a / k) != Math.floor(b / k)) {
        ans = "OK";
    } else if (a % k == b % k) {
        ans = "OK";
    } else {
        ans = "NG";
    }
    // answer
    console.log(ans);
}

// graph lib
/*
function GRAPH_enumPattern(cur: number[], pat: number[][]): number[][] {
    var arr = [];
    for (var patx = 0; patx < pat.length; patx++) {
        var pos = [cur[0] + pat[patx][0], cur[1] + pat[patx][1]];
        arr.push(pos);
    }
    return arr;
}
*/

// math lib
/*
function Math_max(arr: number[]): number { return arr.reduce((x, y) => Math.max(x, y)); }
function Math_min(arr: number[]): number { return arr.reduce((x, y) => Math.min(x, y)); }
function Math_gcd(): number {
    var ans = arguments[0];
    var f = (a: number, b: number): number => b ? f(b, a % b) : a
    for (var i = 1; i < arguments.length; i++) {
        ans = f(ans, arguments[i]);
    }
    return ans
};
function Math_gcdArray(values: number[]): number {
    var ans = values[0];
    var f = (a: number, b: number): number => b ? f(b, a % b) : a
    for (var i = 1; i < values.length; i++) {
        ans = f(ans, values[i]);
    }
    return ans
};
function Math_lcm(): number {
    var a = arguments
    var g = (n: number, m: number): number => m ? g(m, n % m) : n
    var l = (n: number, m: number): number => n * m / g(n, m)
    var ans = a[0]
    for (var i = 1; i < a.length; i++) {
        ans = l(ans, a[i])
    }
    return ans
}
function Math_lcmArray(values: number[]): number {
    var a = values
    var g = (n: number, m: number): number => m ? g(m, n % m) : n
    var l = (n: number, m: number): number => n * m / g(n, m)
    var ans = a[0]
    for (var i = 1; i < a.length; i++) {
        ans = l(ans, a[i])
    }
    return ans
}
function Math_primeList(value: number): number[] {
    var ans = [];
    var arr = new Array(value).fill(0);
    for (var i = 2; i < value; i++) {
        if (arr[i] == 0) {
            for (var j = i; j < value; j += i) {
                if (arr[j] == 0) arr[j] = i;
            }
        }
    }
    for (var i = 2; i < value; i++) {
        if (arr[i] == i) ans.push(i);
    }
    return ans;
}
function Math_primeFactor(p: number[], value: number): number[][] {
    var ans: number[][] = [];
    var valmax = value / 2;;
    for (var i = 0; i < p.length; i++) {
        var prime = p[i];
        if (valmax < prime) break;
        var count = 0;
        while (value % prime == 0) {
            value /= prime;
            count++;
        }
        if (count != 0) {
            ans.push([prime, count]);
        }
        if (value == 1) break;
    }
    return ans;
}
*/

// union-find lib
/*
var g_uf_root: number[];
var g_uf_count: number[];
function UF_initRoot(num: number) {
    g_uf_root = new Array(num).fill(-1);
    g_uf_count = new Array(num).fill(1);
}
function UF_getRoot(index: number) {
    if (g_uf_root[index] < 0) {
        return index;
    } else {
        var work0: number = UF_getRoot(g_uf_root[index]);
        g_uf_root[index] = work0;
        return work0
    }
}
function UF_mergeRoot(a: number, b: number) {
    var root0: number = UF_getRoot(a);
    var root1: number = UF_getRoot(b);
    if (root0 == root1) return;
    if (root0 > root1) [root0, root1] = [root1, root0];
    g_uf_count[root0] += g_uf_count[root1];
    g_uf_count[root1] = 0;
    g_uf_root[root1] = root0;
}
*/

// entrypoint
function entrypoint() {
    try {
        // linux
        var input = fs.readFileSync("/dev/stdin", "utf8").trim().split("\n");
        console.debug = function () { };
        main(input);
    }
    catch (ex) {
        // windows
        const lines: string[] = [];
        // @ts-ignore
        const reader = require('readline').createInterface({
            // @ts-ignore
            input: process.stdin,
            // @ts-ignore
            output: process.stdout
        });
        reader.on('line', function (line: string) {
            lines.push(line);
        });
        reader.on('close', function () {
            input = lines;
            main(input);
        });
    }
}
entrypoint();


import * as fs from 'fs';

// main
function main(input: string[]) {
    // param
    var k: number = 0;
    var a: number = 0;
    var b: number = 0;
    var ans: string = "";
    // init
    k = Number(input.shift());
    [a, b] = input.shift().split(" ").map(x => Number(x));
    // solve
    if (Math.floor(a / k) != Math.floor(b / k)) {
        ans = "OK";
    } else if (a % k == b % k) {
        ans = "OK";
    } else {
        ans = "NG";
    }
    // answer
    console.log(ans);
}

// graph lib
/*
function GRAPH_enumPattern(cur: number[], pat: number[][]): number[][] {
    var arr = [];
    for (var patx = 0; patx < pat.length; patx++) {
        var pos = [cur[0] + pat[patx][0], cur[1] + pat[patx][1]];
        arr.push(pos);
    }
    return arr;
}
*/

// math lib
/*
function Math_max(arr: number[]): number { return arr.reduce((x, y) => Math.max(x, y)); }
function Math_min(arr: number[]): number { return arr.reduce((x, y) => Math.min(x, y)); }
function Math_gcd(): number {
    var ans = arguments[0];
    var f = (a: number, b: number): number => b ? f(b, a % b) : a
    for (var i = 1; i < arguments.length; i++) {
        ans = f(ans, arguments[i]);
    }
    return ans
};
function Math_gcdArray(values: number[]): number {
    var ans = values[0];
    var f = (a: number, b: number): number => b ? f(b, a % b) : a
    for (var i = 1; i < values.length; i++) {
        ans = f(ans, values[i]);
    }
    return ans
};
function Math_lcm(): number {
    var a = arguments
    var g = (n: number, m: number): number => m ? g(m, n % m) : n
    var l = (n: number, m: number): number => n * m / g(n, m)
    var ans = a[0]
    for (var i = 1; i < a.length; i++) {
        ans = l(ans, a[i])
    }
    return ans
}
function Math_lcmArray(values: number[]): number {
    var a = values
    var g = (n: number, m: number): number => m ? g(m, n % m) : n
    var l = (n: number, m: number): number => n * m / g(n, m)
    var ans = a[0]
    for (var i = 1; i < a.length; i++) {
        ans = l(ans, a[i])
    }
    return ans
}
function Math_primeList(value: number): number[] {
    var ans = [];
    var arr = new Array(value).fill(0);
    for (var i = 2; i < value; i++) {
        if (arr[i] == 0) {
            for (var j = i; j < value; j += i) {
                if (arr[j] == 0) arr[j] = i;
            }
        }
    }
    for (var i = 2; i < value; i++) {
        if (arr[i] == i) ans.push(i);
    }
    return ans;
}
function Math_primeFactor(p: number[], value: number): number[][] {
    var ans: number[][] = [];
    var valmax = value / 2;;
    for (var i = 0; i < p.length; i++) {
        var prime = p[i];
        if (valmax < prime) break;
        var count = 0;
        while (value % prime == 0) {
            value /= prime;
            count++;
        }
        if (count != 0) {
            ans.push([prime, count]);
        }
        if (value == 1) break;
    }
    return ans;
}
*/

// union-find lib
/*
var g_uf_root: number[];
var g_uf_count: number[];
function UF_initRoot(num: number) {
    g_uf_root = new Array(num).fill(-1);
    g_uf_count = new Array(num).fill(1);
}
function UF_getRoot(index: number) {
    if (g_uf_root[index] < 0) {
        return index;
    } else {
        var work0: number = UF_getRoot(g_uf_root[index]);
        g_uf_root[index] = work0;
        return work0
    }
}
function UF_mergeRoot(a: number, b: number) {
    var root0: number = UF_getRoot(a);
    var root1: number = UF_getRoot(b);
    if (root0 == root1) return;
    if (root0 > root1) [root0, root1] = [root1, root0];
    g_uf_count[root0] += g_uf_count[root1];
    g_uf_count[root1] = 0;
    g_uf_root[root1] = root0;
}
*/

// entrypoint
function entrypoint() {
    try {
        // linux
        var input = fs.readFileSync("/dev/stdin", "utf8").trim().split("\n");
        console.debug = function () { };
        main(input);
    }
    catch (ex) {
        // windows
        const lines: string[] = [];
        // @ts-ignore
        const reader = require('readline').createInterface({
            // @ts-ignore
            input: process.stdin,
            // @ts-ignore
            output: process.stdout
        });
        reader.on('line', function (line: string) {
            lines.push(line);
        });
        reader.on('close', function () {
            input = lines;
            main(input);
        });
    }
}
entrypoint();


A, B = map(int,input().split())
if A+B >= 10:
  print('error')
else:
  print(A+B)


A, B = map(int, input().split())
if A+B >= 10:
    print("error")
else:
    print(A+B)


a, b = map(int, input().split())
if a+b>9:
    print("error")
else:
    print(a+b)


a,b=map(int, input().split())
print("error" if a*b>=10 else a*b)


a,b = map(int,input().split())

print(a+b if a+b < 10 else error)


A, B = int(input().split())
if A+B < 10:
    print(A+B)
else:
    print('error')


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {

	public static void main(String[] args) throws IOException {
		BufferedReader input =new BufferedReader (new InputStreamReader (System.in));
		String str = input.readLine( );
		String[] ab = str.split(" ");
		int a = Integer.parseInt(ab[0]);
		int b = Integer.parseInt(ab[1]);

		if(a+b < 10){
			System.out.println(a+b);
		}else{
			System.out.println("error");
		}

	}

}


import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;

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

		if (A + B >= 10) {
			System.out.println("error");
		} else {
			System.out.println(A + B);
		}
	}

	public static class Pair {
		private int key;
		private int value;

		public Pair(int key, int value) {
			super();
			this.key = key;
			this.value = value;
		}

		public int getKey() {
			return key;
		}

		public int getValue() {
			return value;
		}

		public void setValue(int value) {
			this.value = value;
		}

		@Override
		public String toString() {
			return "{" + key + ", " + value + "}";
		}
	}

	private static boolean isDebug = System.getProperty("sun.desktop") != null;

	private static void debug(Object... o) {
		if (isDebug) {
			System.err.println(Arrays.deepToString(o));
		}
	}

	public static class Scanner {
		private BufferedInputStream inputStream;

		public Scanner(InputStream in) {
			inputStream = new BufferedInputStream(in);
		}

		public int nextInt() throws IOException {
			int num = 0;
			int sign = 1;

			int read = skip();
			if (read == '-') {
				sign = -1;
				read = inputStream.read();
			}

			do {
				num = num * 10 + sign * (read - 0x30);
			} while ((read = inputStream.read()) > 0x20);

			return num;
		}

		public void fill(int[] a) throws IOException {
			for (int i = 0; i < a.length; i++) {
				a[i] = nextInt();
			}
		}

		public void fill(int[] a, int[] b) throws IOException {
			if (a.length != b.length) {
				throw new IllegalArgumentException();
			}

			for (int i = 0; i < a.length; i++) {
				a[i] = nextInt();
				b[i] = nextInt();
			}
		}

		public void fill(int[] a, int[] b, int[] c) throws IOException {
			if (a.length != b.length || b.length != c.length) {
				throw new IllegalArgumentException();
			}

			for (int i = 0; i < a.length; i++) {
				a[i] = nextInt();
				b[i] = nextInt();
				c[i] = nextInt();
			}
		}

		public long nextLong() throws IOException {
			long num = 0;

			int read = skip();
			do {
				num = num * 10 + (read - 0x30);
			} while ((read = inputStream.read()) > 0x20);

			return num;
		}

		public void fill(long[] a) throws IOException {
			for (int i = 0; i < a.length; i++) {
				a[i] = nextLong();
			}
		}

		public void fill(long[] a, long[] b) throws IOException {
			if (a.length != b.length) {
				throw new IllegalArgumentException();
			}

			for (int i = 0; i < a.length; i++) {
				a[i] = nextLong();
				b[i] = nextLong();
			}
		}

		public long[] nextLong(int n) throws IOException {
			long[] array = new long[n];
			for (int i = 0; i < n; i++) {
				array[i] = nextLong();
			}

			return array;
		}

		public String next() throws IOException {
			StringBuilder builder = new StringBuilder();

			int read = skip();
			do {
				builder.append((char) read);
			} while ((read = inputStream.read()) > 0x20);

			return builder.toString();
		}

		private int skip() throws IOException {
			int read;
			while ((read = inputStream.read()) <= 0x20)
				;

			return read;
		}
	}
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {
    public static void main(String[] args) {
        try {
            // 標準入力
            InputStreamReader isr = new InputStreamReader(System.in);
            BufferedReader br = new BufferedReader(isr);
            String strArr[] = br.readLine().split(" ");
            int a = Integer.parseInt(strArr[0]);
            int b = Integer.parseInt(strArr[1]);
            int sum = a + b;
            if (sum >= 10) {
                System.out.println("error");
            } else {
                System.out.println(sum);
            }
       } catch (IOException e) {
            e.printStackTrace();
       }
    }
}


import java.util.Scanner;

public class A063 {

	public static void main(String[] args) {
		// TODO 自動生成されたメソッド・スタブ
		Scanner stdIn = new Scanner(System.in);
		int A = stdIn.nextInt();
		int B = stdIn.nextInt();

		if(A+B >= 10)
		{
			System.out.println("error");
		}
		else
		{
			System.out.println(A+B);
		}
	}

}


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

public class Main {
	public static void main(String[] args) {

		for(int i=0;i<1;i++) {

			slover();
			out.flush();
		}
	}
	static FastScanner sc = new FastScanner();
	static PrintWriter out = new PrintWriter(System.out);
	//StringBuffer S = new StringBuffer(sc.next());
		//String hoge2 = str.reverse().toString();
		//map.containsKey(A)
		//Map<Integer, Integer> map = new HashMap<Integer, Integer>(N);
		/*for ( キーのデータ型 key : マップの名前.keySet() ) {
			データのデータ型 data = マップの名前.get( key );

			// keyやdataを使った処理;
		}*/
		//int i = Integer.parseInt(s);
		//Queue<String> qq=new ArrayDeque<>(); //add,poll,peek BFSは前から実行される
		//Deque<String> dd=new ArrayDeque<>();//push後ろに入れる,poll(pop)後ろからとる,peek addは先頭に入るからバグ注意
		//stackdfsは後ろから実行される
		//ArrayList<Integer> cc = new ArrayList<>(N);
		//cc.contains(tmp)
		//Arrays.asList(c).contains("a")
		//list.set(1,"walk");//1 1 2 3 5
		//PriorityQueue<Integer> r=new PriorityQueue<Integer>();//add poll
	//Set<Long> a=new HashSet<Long>();
	//Integer.toBinaryString(i);
	//Integer.toString(i, 2);
//	//Integer.parseInt(bin, 2);
	//bitset

	private static int slover()   {

		double a=sc.nextInt();
		double b=sc.nextInt();
		if(a+b>=10)p("error");
		else p((int)a+b);

		return 0;
	}
private static class D{
		int x,y;
		D(int x,int y){
			this.x=x;;
			this.y=y;

		}

	}
	static void p(String ans) {out.println(ans);};
	static void p(int ans) {out.println(ans);};
	static void p() {out.println();};
	static void p(long ans) {out.println(ans);};
	static void p(double ans) {out.println(ans);};

	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 double nextDouble(){
	    	return Double.parseDouble(next());
	    }

	    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.util.*;
import java.io.*;

public class Main {
    static class FS {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer("");

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

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

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

        int[] readArray(int n) {
            int[] a = new int[n];
            for (int i = 0; i < n; i++)
                a[i] = nextInt();
            return a;
        }

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

        public long[] readLongArray(int n) {
            long[] a = new long[n];
            for (int i = 0; i < n; i++)
                a[i] = nextLong();
            return a;
        }
    }

    static final FS sc = new FS();
    static final PrintWriter out = new PrintWriter(System.out);
    static final int mod = 1000000007;

    public static void main(String[] args) {

        solve();
        out.close();

    }

    static void solve() {
        int a = sc.nextInt();
        int b = sc.nextInt();
        if (a + b == 10) {
            out.println("error");
        } else {
            out.println(a + b);
        }
    }
}


#include<stdio.h>
#include<string.h>
int main(){
	int a,b;
	while(scanf("%d%d",&a,&b)!=EOF){
		if(a+b<10)
			printf("%d\n",a+b);
			else
			printf("error\n");
	}
	return 0;
}


#include <stdio.h>
int main(int argc, char *argv[])
{
	int  a,b;
	scanf("%d%d",&a,&b);
	 if(a+b<10) printf("%d",a+b);
	 else printf("error");
	return 0;
}


#include<stdio.h>
int main()
{
	int a,b;
	scanf("%d%d",&a,&b);
	if(a+b<10)
	 printf("%d",a+b);
    else printf("error");
}


#include <bits/stdc++.h>

#define ln "\n"
#define SORT(X) sort(X.begin(), X.end())
#define SORTi(X) sort(X.begin(), X.end(), greater<ll>())
#define REP(x, a, b) for (auto x = a; x <= b; x++)
#define REPi(x, b, a) for (auto x = b; x >= a; x--)
#define REPit(x, A) for (auto x = A.begin(); x != A.end(); x++)
#define REPr(x, A) for (auto x : A)
#define ll long long
#define ull unsigned long long
#define PB push_back
#define EB emplace_back
#define UMP unordered_map
#define UST unordered_set

using namespace std;

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(NULL);

    ll N = 0;
    cin >> N;
    ll sum = 0;
    vector<ll> A(N);
    REP(i, 0, N - 1)
    {
        cin >> A[i];
        sum = sum + A[i];
    }
    SORT(A);
    if (sum % 10 == 0)
    {
        REP(i, 0, N)
        {
            if (A[i] % 10 != 0)
            {
                sum = sum - A[i];
                break;
            }
        }
    }
    if (sum % 10 == 0)
        cout << 0 << ln;
    else
        cout << sum << ln;
    return 0;
}


#include<bits/stdc++.h>

#define Vsort(a) sort(a.begin(), a.end())
#define Vreverse(a) reverse(a.begin(), a.end())
#define Srep(n) for(int i = 0; i < (n); i++)
#define Lrep(i,a,n) for(int i = (a); i < (n); i++)
#define Brep(n) for(int bit = 0; bit < (1<<n); bit++)
#define rep2nd(n,m) Srep(n) Lrep(j,0,m)
#define vi vector<int>
#define vi64 vector<int64_t>
#define vvi vector<vector<int>>
#define vvi64 vector<vector<int64_t>>

using namespace std;

int main(){
  int a,b;
  cin >> a >> b;
  cout << (a + b < 10 ? a + b : "error") << endl;
}


#include<bits/stdc++.h>

#define Vsort(a) sort(a.begin(), a.end())
#define Vreverse(a) reverse(a.begin(), a.end())
#define Srep(n) for(int i = 0; i < (n); i++)
#define Lrep(i,a,n) for(int i = (a); i < (n); i++)
#define Brep(n) for(int bit = 0; bit < (1<<n); bit++)
#define rep2nd(n,m) Srep(n) Lrep(j,0,m)
#define vi vector<int>
#define vi64 vector<int64_t>
#define vvi vector<vector<int>>
#define vvi64 vector<vector<int64_t>>

using namespace std;

int main(){
  int a,b:
  cin >> a >> b;
  cout << (a + b < 10 ? a + b : "error") << endl;
}


#include <stdio.h>

int main(void) {
	int a; int b;
	scanf("%d%d", &a,&b);
	if(a+b>=10) {
		printf("error");
	}
	else {
		printf("%d\n",a+b );
	}
}


#include <stdio.h>

int main(void)
{
	int a, b;

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

	if(a+b >= 10)
		printf("error\n");
	else
		printf("%d\n", a+b);

	return 0;
}


#include <stdio.h>

int main()
{
    int a,b;
    scanf("%d%d",&a,&b);
    int c=0;
    c=a+b;
    if(c>=10)
        printf("error");
    else
    printf("%d",c);
    return 0;
}


#include <stdio.h>

int	main(void)
{
  int	i = 0;
  int	j = 0;

  scanf("%d %d", i, j);
  if ((i + j) >= 10)
    printf("error");
  else
    printf("%d", i + j);
  return (0);
}


#include <stdio.h>

int	main(void)
{
  int	i = 0;
  int	j = 0;

  scanf("%d %d", &i, &j);
  if (i + j > 10)
    printf("error");
  else
    printf("%d", i + j);
  return (0);
}


#include <stdio.h>

int	main(void)
{
  int	i = 0;
  int	j = 0;

  scanf("%d %d", i, j);
  if (i + j > 10)
    printf("error");
  else
    printf("%d", i + j);
  return (0);
}


/**
 * @param {String} input
 */
function Main(input){
    const inputs = input.split(' ');
    const num = Number(inputs[0]) + Number(inputs[1]);
    if(num >= 10) return "error";
    return num;
}
console.log(Main(require("fs").readFileSync("/dev/stdin", "utf8")));


"use strict";
const Main = (input) => {
	let xs = input.trim().split(' ').map(v=>parseInt(v,10));
    let ans = '';
    if(xs[0] + xs[1] < 10){
    	ans = xs[0] + xs[1];
    }else if(xs[0] + xs[1] >= 10){
        ans = "error";
    }
    console.log(ans);
}
Main(require('fs').readFileSync('/dev/stdin','utf8'));


function Main(input) {
  const numbers = input.split(' ').map(n => Number(n));
  const a = numbers[0];
  const b = numbers[1];
  if(a + b >= 10) {
    console.log('error');
  } else {
    console.log(a + b);
  }
}

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


function sum(a,b){
    const add = a+b;
    if(add >= 10){
        return "error";
    }
    return add;
}

const readline = require("readline");
const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

rl.question("", function(x) {
    rl.question("", function(y) {
        const value1 = parseInt(x);
        const value2 = parseInt(y);
        const result = sum(value1,value2);
        console.log(result);
        rl.close();
    });
});


function sum(a,b){
    const add = a+b;
    if(add >= 10){
        return "error";
    }
    return add;
}

const readline = require("readline");
const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

rl.question("Give me A=", function(x) {
    rl.question("Give me B=", function(y) {
        const value1 = parseInt(x);
        const value2 = parseInt(y);
        const result = sum(value1,value2);
        console.log(result);
        rl.close();
    });
});


function sum(a,b){
    const add = a+b;
    if(add >= 10){
        return "error";
    }
    return add;
}

const result1 = sum(1,2);
console.log(result1);

const result2 = sum(1,11);
console.log(result2);


package main

import "fmt"

func main() {
	var a, b int
	fmt.Scan(&a, &b)
	sum := a + b
	if sum >= 10 {
		fmt.Println("error")
	} else {
		fmt.Println(sum)
	}
}


package main

import (
	"fmt"
)

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

	if a+b >= 10 {
		fmt.Println("error")
	} else {
		fmt.Println(a + b)
	}
}


package main

import (
	"bufio"
	"fmt"
	"math"
	"os"
	"reflect"
	"sort"
	"strconv"
	"strings"
	// "regexp"
)

/* sort */
type pair struct {
	index  int64
	p1, p2 interface{}
}
type pairs []pair

func (slice pairs) Len() int {
	return len(slice)
}

func (slice pairs) Less(i, j int) bool {
	return slice[i].index < slice[j].index
}

func (slice pairs) Swap(i, j int) {
	slice[i], slice[j] = slice[j], slice[i]
}

/* sort */
type Int64Slice []int64

func (slice Int64Slice) Len() int {
	return len(slice)
}

func (slice Int64Slice) Less(i, j int) bool {
	return slice[i] < slice[j]
}

func (slice Int64Slice) Swap(i, j int) {
	slice[i], slice[j] = slice[j], slice[i]
}
func Int64s(a []int64)                    { sort.Sort(Int64Slice(a)) }
func Int64sSliceAreSorted(a []int64) bool { return sort.IsSorted(Int64Slice(a)) }

const (
	initialBufSize = 1e4
	maxBufSize     = 1e8
	INF            = 1e8
)

var (
	scanner = bufio.NewScanner(os.Stdin)
	writer  = bufio.NewWriter(os.Stdout)
	di      = []int64{-1, 0, 1, 0}
	dj      = []int64{0, -1, 0, 1}
)

func main() {
	buf := make([]byte, initialBufSize)
	scanner.Buffer(buf, maxBufSize)
	scanner.Split(bufio.ScanWords)
	A, B := readInt(), readInt()
	if A+B >= 10 {
		fmt.Println("error")
	} else {
		fmt.Println(A + B)
	}
}

/*==========================================
 *             Library
 *==========================================*/
func NextPermutation(x sort.Interface) bool {
	n := x.Len() - 1
	if n < 1 {
		return false
	}
	j := n - 1
	for ; !x.Less(j, j+1); j-- {
		if j == 0 {
			return false
		}
	}
	l := n
	for !x.Less(j, l) {
		l--
	}
	x.Swap(j, l)
	for k, l := j+1, n; k < l; {
		x.Swap(k, l)
		k++
		l--
	}
	return true
}
func doubleAry(h int64, w int64, init int64) (res [][]int64) {
	res = make([][]int64, h)
	for i := int64(0); i < h; i++ {
		res[i] = make([]int64, w)
		for j := int64(0); j < w; j++ {
			res[i][j] = init
		}
	}
	return
}

func aryEq(a []int64, b []int64) bool {
	return reflect.DeepEqual(a, b)
}

func clone(n []int64) (r []int64) {
	r = make([]int64, len(n))
	for i := 0; i < len(n); i++ {
		r[i] = n[i]
	}
	return
}
func write(s string) {
	writer.WriteString(s)
}

func print() {
	writer.Flush()
}

// scanner.Split(bufio.ScanWords) をコメントアウトしないと使用不可
func readLine() (s string) {
	if scanner.Scan() {
		s = scanner.Text()
	}
	return s
}

func readInt() (read int64) {
	scanner.Scan()
	read, err := strconv.ParseInt(scanner.Text(), 10, 64)
	if err != nil {
		panic(err)
	}
	return
}

func readFloat() (read float64) {
	scanner.Scan()
	read, err := strconv.ParseFloat(scanner.Text(), 64)
	if err != nil {
		panic(err)
	}
	return
}

func readRunes() (read []rune) {
	scanner.Scan()
	for _, v := range scanner.Text() {
		read = append(read, v)
	}
	return
}

func readString() (read string) {
	scanner.Scan()
	read = scanner.Text()
	return
}

func readStrings() (read []string) {
	scanner.Scan()
	for _, v := range scanner.Text() {
		read = append(read, string(v))
	}
	return
}

func s2i(s string) int64 {
	var intVal, e = strconv.ParseInt(s, 10, 64)
	if e != nil {
		panic(e)
	}
	return intVal
}

func i2s(i int64) string {
	var strVal = strconv.FormatInt(i, 10)
	return strVal
}

func s2f(s string) float64 {
	var floatVal, e = strconv.ParseFloat(s, 64)
	if e != nil {
		panic(e)
	}
	return floatVal
}

func abs(i int64) int64 {
	return int64(math.Abs(float64(i)))
}

func max(a ...int64) int64 {
	ans := int64(0)
	for i, v := range a {
		if i == 0 {
			ans = v
		}
		if ans < v {
			ans = v
		}
	}
	return ans
}
func min(a ...int64) int64 {
	ans := int64(0)
	for i, v := range a {
		if i == 0 {
			ans = v
		}
		if ans > v {
			ans = v
		}
	}
	return ans
}

func sum(i []int64) int64 {
	sum := int64(0)
	for _, val := range i {
		sum += val
	}
	return sum
}

func split(s string) []string {
	return strings.Fields(s)
}

func strAry2intAry(strs []string) []int64 {
	var ret = make([]int64, 0, len(strs))
	for _, str := range strs {
		var intVal = s2i(str)
		ret = append(ret, intVal)
	}
	return ret
}

func intAry2strAry(nums []int64) []string {
	var ret = make([]string, 0, len(nums))
	for _, num := range nums {
		var strVal = i2s(num)
		ret = append(ret, strVal)
	}
	return ret
}

func ary2str(strs []string) string {
	return strings.Join(strs, " ")
}

func reverse(res []int64) []int64 {
	for i, j := 0, len(res)-1; i < j; i, j = i+1, j-1 {
		res[i], res[j] = res[j], res[i]
	}
	return res
}
func reverseStr(res []string) []string {
	for i, j := 0, len(res)-1; i < j; i, j = i+1, j-1 {
		res[i], res[j] = res[j], res[i]
	}
	return res
}

func ini(res []int, init int) {
	if len(res) == 0 {
		return
	}
	res[0] = init
	for i := 0; i < len(res); i++ {
		copy(res[i:], res[:i])
	}
}

//
// func regexpExample() {
//     // Your code here!
//     var str = "13:20"
//     r := regexp.MustCompile(`(\d+):(\d+)`)
//     fmt.Println(r.FindStringSubmatch(str))
// }

// type Country struct {
//     gold int
//     silver int
//     blonze int
// }

// // 複数ソートのサンプル
// func stableSortExample() []Country{
//     var country = []Country {
//         {gold:1, silver:2, blonze:3},
//         {gold:1, silver:2, blonze:3},
//         {gold:1, silver:3, blonze:2},
//         {gold:1, silver:3, blonze:3},
//     }
//     sort.SliceStable(country, func(i, j int) bool { return country[i].blonze > country[j].blonze })
//     sort.SliceStable(country, func(i, j int) bool { return country[i].silver > country[j].silver })
//     sort.SliceStable(country, func(i, j int) bool { return country[i].gold > country[j].gold })
//     return country
// }


package main

import (
	"fmt"
)

func main() {
	var a, b int
	if (a + b) < 10 {
		fmt.Println(a + b)
	} else {
		fmt.Println("error")
	}
}


package main

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

func main() {
	In := readLineInt()
	Result := In[0] + In[1]
	if Result >= 10 {
		fmt.Println("error")
	} else {
		fmt.Println(Result)
	}
}

/////////////////////////////////////////

func readLineInt() []int {
	result := make([]int, 0)
	for _, v := range strings.Split(readLine(), " ") {
		i, _ := strconv.Atoi(v)
		result = append(result, i)
	}
	return result
}

var reader = bufio.NewReaderSize(os.Stdin, 1e6)

func readLine() string {
	result := make([]byte, 0, 1e6)
	for {
		line, remains, e := reader.ReadLine()
		if e != nil {
			panic(e)
		}
		result = append(result, line...)
		if !remains {
			break
		}
	}
	ret


package main

import "fmt"

func main() {
	var a, b int
	fmt.Scan(&a, &b)
	if a + b <= 10 {
		fmt.Println(a + b)
	} else {
		fmt.Println("error")
	}
}


a, b = gets.chomp.split.map(&:to_i)
puts a + b >= 10 ? 'error' : a + b


a,b = gets.split.map(&:to_i)

if a+b >= 10
  puts "error"
else
  puts a+b
end


x = gets.chomp.split.map(&:to_i)
y = x.inject(:+)
if y >= 10
  puts "error"
  exit
end
puts y


a=gets.split.map(&:to_i).sum
puts a<=10 ? a : "error"


a gets.split.map(&:to_i).reduce(:+)

puts a > 9 ? 'error' : a


str = gets
arr = str.split(" "),map(&:to_i)

sum = arr[0] + arr[1]
puts sum >= 10 ? 'error' : sum


macro_rules! get {
    ($t:ty) => {
        {
            let mut line: String = String::new();
            std::io::stdin().read_line(&mut line).unwrap();
            line.trim().parse::<$t>().unwrap()
        }
    };
    ($($t:ty),*) => {
        {
            let mut line: String = String::new();
            std::io::stdin().read_line(&mut line).unwrap();
            let mut iter = line.split_whitespace();
            (
                $(iter.next().unwrap().parse::<$t>().unwrap(),)*
            )
        }
    };
    ($t:ty; $n:expr) => {
        (0..$n).map(|_|
            get!($t)
        ).collect::<Vec<_>>()
    };
    ($($t:ty),*; $n:expr) => {
        (0..$n).map(|_|
            get!($($t),*)
        ).collect::<Vec<_>>()
    };
}

fn main() {
    let (a, b) = get!(i32, i32);
    let x = a + b;
    if x < 10 {
        println!("{}", x);
    } else {
        println!("error");
    }
}


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;
use std::cmp::min;

fn main() {
    let a: usize = read();
    let b: usize = read();
    if a + b >= 10 {
        println!("{}", "error");
    } else {
        println!("{}", a + b);
    }
}