codeparrot/codecomplex huggingface dataset:
// Problem: 1_B. Spreadsheets
// Time complexity: linear
/**
 * Created by IntelliJ IDEA.
 * User: Nick
 * Date: 08.08.2010
 * Time: 20:44:02
 * To change this template use File | Settings | File Templates.
 */
import java.io.*;
import java.util.*;
import java.util.regex.*;

public class B {
    public static void main(String[] args) {
        Scanner input = new Scanner (System.in);
        Pattern rc_style = Pattern.compile("R[0-9]+C[0-9]+");
        int n = input.nextInt();
        while(n-- > 0) {
            String str = input.next();
            Matcher m = rc_style.matcher(str);
            if (m.matches()) {
                String nums[] = str.split("[RC]");
                String row = nums[1];
                String col = nums[2];
                String buffer = "";
                int col_num = Integer.valueOf(col);
                while(col_num > 0) {
                    if (col_num % 26 > 0) {
                        buffer += (char)(col_num % 26 + 'A' - 1);
                        col_num /= 26;
                    } else {
                        buffer += 'Z';
                        col_num /= 26;
                        col_num--;
                    }
                }
                for (int i = buffer.length() - 1; i >= 0; --i) {
                    System.out.print(buffer.charAt(i));
                }
                System.out.println(row);
            } else {
                String col = str.split("[0-9]+")[0];
                String row = str.split("[A-Z]+")[1];

                int col_num = 0;
                int shift = 1;
                for (int i = col.length() - 1; i >= 0; --i){
                    col_num += (int)(col.charAt(i) - 'A' + 1) * shift;
                    shift *= 26;
                }
                System.out.println("R" + row + "C" + col_num);
            }
        }
    }
}
// Problem: 1_B. Spreadsheets
// Time complexity: linear
import java.io.*;         
import java.util.*;         
import java.math.*;         
import java.awt.geom.*;         
import java.util.regex.*;
public class Main implements Runnable  {
StreamTokenizer ST;      
PrintWriter out;      
BufferedReader br;   
int inf = 1000000000;


int nextInt() throws IOException{      
    ST.nextToken();      
    return (int)ST.nval;      
}

long nextLong() throws IOException{      
    ST.nextToken();      
    return (long)ST.nval;      
}      
String next() throws IOException{      
    ST.nextToken();      
    return ST.sval;      
}      
double nextD() throws IOException{      
    ST.nextToken();      
    return ST.nval;      
}      
public static void main(String[] args) throws IOException {       
    new Thread(new Main()).start();      
}

public void run()  {      
    try {          
        br = new BufferedReader(new InputStreamReader(System.in));
        //br = new BufferedReader(new InputStreamReader(System.in, "ISO-8859-1"));
        out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
        
        ST = new StreamTokenizer(br);      
        solve();      
        out.close();
        br.close();            
    }         
    catch (IOException e) {        
        throw new IllegalStateException(e);       
    }      
}


String code(int x) {
    x--;
    StringBuilder sb = new StringBuilder();
    while (x>0) {
        int c = x%26;
        if (x<10) sb.append((char)(c+'0')); else sb.append((char)('A'+c-10));
        x /= 26;
    }
    if (sb.length()==0) sb.append("0");
    return sb.toString();
}
StringBuilder sb = new StringBuilder();
public void solve() throws IOException {
    int tt = Integer.parseInt(br.readLine());
    HashMap<String, Integer> map = new HashMap<String, Integer>();
    for (int i=1; i<=10; i++) map.put(code(i), i);

    while (tt-->0) {
        String s = br.readLine();
        if (s.matches("^[A-Z]+[0-9]+$")) {
            int t = 0;
            while (Character.isLetter(s.charAt(t))) t++;
            int r = Integer.parseInt(s.substring(t));
            s = s.substring(0, t);
            int res = 0;
            for (int c:s.toCharArray()) {
                res *= 26;
                res += c-'A'+1;
            }
            out.println("R"+r+"C"+res);
        } else {
            int t = s.indexOf('C');
            int c = Integer.parseInt(s.substring(1, t));
            int r = Integer.parseInt(s.substring(t+1));
            //out.println(r+" "+c);
            sb.setLength(0);
            while (r>0) {
                r--;
                int ch = r%26;
                sb.append((char)('A'+ch));
                r /= 26;
            }
            sb = sb.reverse();
            out.println(sb+""+c);
        }
        
    }
    
    
}
}
// Problem: 1_B. Spreadsheets
// Time complexity: linear


import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;

public class B {
	private Scanner in;
	private PrintWriter out;
	
	public void solve()
	{
		String str = in.next();
		
		List<String> sp = new ArrayList<String>();
		StringBuilder sb = null;
		int kind = -1;
		for(int i = 0;i < str.length();i++){
			char c = str.charAt(i);
			if(c >= 'A' && c <= 'Z' && kind != 0){
				if(sb != null){
					sp.add(sb.toString());
				}
				sb = new StringBuilder();
				kind = 0;
			}
			if(c >= '0' && c <= '9' && kind != 1){
				if(sb != null){
					sp.add(sb.toString());
				}
				sb = new StringBuilder();
				kind = 1;
			}
			sb.append(c);
		}
		sp.add(sb.toString());
		if(sp.size() == 2){
			// BC23
			String bc = sp.get(0);
			int v = 0;
			for(int i = 0;i < bc.length();i++){
				v = 26 * v + (bc.charAt(i) - 'A' + 1);
			}
			
			out.println("R" + sp.get(1) + "C" + Integer.toString(v));
		}else{
			// R23C55
			
			int v = Integer.parseInt(sp.get(3));
			StringBuilder sbb = new StringBuilder();
			for(;v > 0;v/=26){
				v--;
				sbb.append((char)((v % 26) + 'A'));
			}
			sbb.reverse();
			
			out.println(sbb.toString() + sp.get(1));
		}
		
		out.flush();
	}
	
	public void run() throws Exception
	{
//		in = new Scanner(new BufferedReader(new InputStreamReader(new FileInputStream("input.txt"))));
//		out = new PrintWriter(new FileWriter(new File("output.txt")));
//		in = new Scanner(new StringReader("2\nR23C55\nR26C26\nZ26"));
		in = new Scanner(System.in);
//		System.setOut(new PrintStream(new BufferedOutputStream(System.out)));
		out = new PrintWriter(System.out);
		
		int n = in.nextInt();
//		int n = 1;
		for(int i = 1;i <= n;i++){
			long t = System.currentTimeMillis();
			solve();
//			System.err.printf("%04d/%04d %7d%n", i, n, System.currentTimeMillis() - t);
		}
	}
	
	
	public static void main(String[] args) throws Exception
	{
		new B().run();
	}
	
	private int ni() { return Integer.parseInt(in.next()); }
	private static void tr(Object... o) { System.out.println(o.length == 1 ? o[0] : Arrays.toString(o)); }
	private void tra(int[] a) {System.out.println(Arrays.toString(a));}
	private void tra(int[][] a)
	{
		for(int[] e : a){
			System.out.println(Arrays.toString(e));
		}
	}
	
}
// Problem: 1_B. Spreadsheets
// Time complexity: linear
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;


public class Main {
	public static void main(String[] args) {
		Scanner scn = new Scanner(System.in);
		
		int t = scn.nextInt();
		while(t-- >0){
			String str = scn.next();
			Pattern p = Pattern.compile("R[0-9]+C[0-9]+");
			Matcher m = p.matcher(str);
			if (m.matches()){
				String nums[] = str.split("[RC]");
				String first = nums[1];
				String second = nums[2];
				
				String ans = "";
				long num = Integer.parseInt(second);
				while(num >0){
					if (num % 26 > 0){
						ans += (char)(num%26+'A'-1);
						num/=26;
					} else {
						ans += 'Z';
						num/=26;
						num--;
					}
				}
				for (int i = ans.length()-1; i>=0;--i){
					System.out.print(ans.charAt(i));
				}
				
				System.out.println(first);
			} else {
				String first = str.split("[0-9]+")[0];
				String second = str.split("[A-Z]+")[1];
				System.out.print("R"+second);
				
				long num = 0, pow = 1;
				for (int i = first.length()-1; i>=0; --i){
					num += (long)(first.charAt(i)-'A'+1) * pow;
					pow*=26;
				}
				System.out.println("C"+num);
			}
			
		}
	}
}
// Problem: 1_B. Spreadsheets
// Time complexity: linear
import java.util.*;
import java.math.*;
import java.io.*;

public class b implements Runnable{
	PrintWriter out = null;
	public int toint(String s){
		int res = 0;
		for (int i = 0; i < s.length(); i++){
			res *= 10;
			res += s.charAt(i)-'0';
		}
		return res;
	}

	public void tostr(int k){
		if (k == 0) return;
		tostr((k-1)/26);
		out.print((char)(('A'+((k-1)%26))));
	}

	public int fromstr(String s){
		if (s.length() == 0) return 0;
		int r = s.charAt(s.length()-1)-'A'+1;
		r += 26*(fromstr(s.substring(0,s.length()-1)));
		return r;
	}

        public void run(){
                try{
                        Scanner in = new Scanner(System.in);
                        out = new PrintWriter(System.out);
                        int n = in.nextInt();
						for (int t = 0; t < n; t++){
							int rp = -1;
							int cp = -1;
							String s = in.next();
							for (int i = 0; i < s.length(); i++)
								if (s.charAt(i) == 'R') rp = i;
								else if (s.charAt(i) == 'C') cp = i;
							boolean good = true;
							if (rp == 0 && cp > 1){
								for (int i = 0; i <= cp; i++)
									if (s.charAt(i) >= '0' && s.charAt(i) <= '9')
										good = false;
							}
							if (good){
								int k = 0;
								for (;s.charAt(k) < '0' || s.charAt(k) > '9'; k++);
								int r = toint(s.substring(k,s.length()));
								int c = fromstr(s.substring(0,k));
								out.print('R');
								out.print(r);
								out.print('C');
								out.println(c);
							} else {
								int r = toint(s.substring(1,cp));
								int c = toint(s.substring(cp+1,s.length()));
								tostr(c);
								out.println(r);
							}
						}
                        in.close();
                        out.close();
                } catch(Exception e){
                        e.printStackTrace();
                }
        }

        public static void main(String[] args){
                new Thread(new b()).start();
        }
}
// Problem: 1_B. Spreadsheets
// Time complexity: linear

import java.util.*;
import java.util.regex.*;

public class Main {
    public static void main(String[] args) {
	Scanner input = new Scanner(System.in);
	Pattern rc_style = Pattern.compile("R[0-9]+C[0-9]+");
	int n = input.nextInt();

	while(n-- > 0) {
	    String str = input.next();
	    Matcher m = rc_style.matcher(str);

	    if(m.matches()) {
		String nums[] = str.split("[RC]");
		String row = nums[1];
		String col = nums[2];
		
		String buffer = "";
		int col_num = Integer.valueOf(col);
		while(col_num > 0) {
		    if(col_num % 26 > 0) {
			buffer += (char)(col_num % 26 + 'A' - 1);
			col_num /= 26;
		    } else {
			buffer += 'Z';
			col_num /= 26;
			col_num--;
		    }
		}

		for(int i = buffer.length() - 1; i >= 0; i--)
		    System.out.print(buffer.charAt(i));
		
		System.out.println(row);

	    } else {
		String col = str.split("[0-9]+")[0];
		String row = str.split("[A-Z]+")[1];

		int col_num = 0;
		int shift = 1;
		for(int i = col.length() - 1; i >= 0; i--) {
		    col_num += (int) (col.charAt(i) - 'A' + 1) * shift;
		    shift *= 26;
		}

		System.out.println("R" + row + "C" + col_num);
	    }
	}
    }
}
// Problem: 1_B. Spreadsheets
// Time complexity: linear

import java.util.Scanner;

public class B {
    public static String toB(String str){
        String row,col;
        int i=0;
        while(i<str.length() && str.charAt(i)<='Z'&&str.charAt(i)>='A')i++;
        col = str.substring(0,i);
        row = str.substring(i,str.length());
        StringBuffer sb = new StringBuffer(col);
        col = sb.reverse().toString();
        int accum = 0;
        for(i=0;i<col.length();i++){
            int val = getValue(col.charAt(i));
            accum+=val*Math.pow(26, i);
            }
        return "R"+row+"C"+accum;
        
    }
    public static String toA(String str){
        int i = str.indexOf('C');
        String row,col,ans="";
        row = str.substring(1,i);
        col = str.substring(i+1,str.length());
        int colVal = Integer.parseInt(col),mod;
        while(colVal>0){
            mod = colVal%26;
            if(mod==0){
                ans+='Z';
                colVal--;
            }
            else{
                ans+=getLetter(mod);
            }
            colVal/=26;
        }
        StringBuffer sb = new StringBuffer(ans);
        ans = sb.reverse().toString();
        return ans+row;
    }
    public static int getValue(char c){
        return c-'A'+1;
    }
    public static char getLetter(int n){
        return (char)(n+'A'-1);
    }
    public static void main(String[] args)throws Exception{
        Scanner in = new Scanner(System.in);
        int cases = in.nextInt();
        for(int i = 0;i<cases;i++){
            String str = in.next();
            if(str.charAt(0)=='R' && str.charAt(1)>='0'&&str.charAt(1)<='9' && str.indexOf('C')!=-1){
                System.out.println(toA(str));
            }
            else System.out.println(toB(str));
        }
        
    }
}
// Problem: 1_B. Spreadsheets
// Time complexity: linear
import java.io.*;
import java.util.regex.*;

public class Main {

	private static String encode(long rowNum) {
			if(rowNum<=26) {
				return String.valueOf((char)('A'+rowNum-1));
			}
			else {
				
				if(rowNum%26==0){
					return encode((long)Math.floor((double)rowNum/26)-1) 
					+ String.valueOf((char)('A'+26-1));				
				}
				else {
					return encode((long)Math.floor((double)rowNum/26)) 
					+ String.valueOf((char)('A'+rowNum%26-1));
				}
			}
	}
	
	private static long decode(String rowNum){
		long result = 0;
		char rowChars[] = rowNum.toCharArray();
		for(int i=rowChars.length-1;i>=0;i--){
			result+= (rowChars[i]-'A'+1) * (long)Math.pow(26,rowChars.length-i-1);
		}
		return result;
	}
	
	public static void main(String arg[])throws IOException {
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		int t = Integer.parseInt(in.readLine());
		Pattern p1 = Pattern.compile("R\\d+C\\d+");
		Pattern p2 = Pattern.compile("\\d+");
		for(int i=0;i<t;i++){
			String input = in.readLine();
			Matcher m1 = p1.matcher(input);
			Matcher m2 = p2.matcher(input);
			if(m1.matches()){
				String result = "";
				if(m2.find()){
					result = m2.group();
				}
				if(m2.find()){
					result = encode(Long.parseLong(m2.group()))+result;
				}
				System.out.println(result);
			}
			else {
				String result = "R";
				if(m2.find()){
					result += m2.group();
				}				
				result += "C";
				System.out.println(result+decode(input.replaceAll(m2.group(),"")));
			}
		}
	}
}
// Problem: 1_B. Spreadsheets
// Time complexity: linear
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Round1B {

	public static void main(String[] args) throws Exception {
		new Round1B().run();
	}

	private void run() throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		int tc = Integer.parseInt(br.readLine().trim());
		while (tc > 0) {
			String s = br.readLine().trim();
			if (s.matches("R[0-9]+C[0-9]+")) {
				Pattern p = Pattern.compile("R([0-9]+)C([0-9]+)");
				Matcher m = p.matcher(s);
				if (m.matches()) {
					int rows = Integer.parseInt(m.group(1));
					int cols = Integer.parseInt(m.group(2));
					String col = "";
					while (cols > 0) {
						int mod = (cols - 1) % 26;
						col = (char)('A' + mod) + col;
						cols = (cols - 1) / 26;
					}
					System.out.println(col + rows);
				} else {
					throw new Exception();
				}
			} else {
				Pattern p = Pattern.compile("([A-Z]+)([0-9]+)");
				Matcher m = p.matcher(s);
				if (m.matches()) {					
					int rows = Integer.parseInt(m.group(2));
					int cols = 0;
					int mul = 1;
					for (int i = m.group(1).length() - 1; i >= 0; i--) {
						cols += mul * (m.group(1).charAt(i) - 'A' + 1);
						mul *= 26;
					}
					System.out.printf("R%dC%d\n", rows, cols);
				}
				else {
					throw new Exception();
				}
			} 
			tc--;
		}
		br.close();
	}

}
// Problem: 1_B. Spreadsheets
// Time complexity: linear
import java.io.PrintWriter;
import java.util.*;

/*
10
R1C1
A1
R1C26
Z1
R1C27
AA1
R1C28
AB1
R1C52
AZ1

 */

public class Main {

	Scanner in;
	PrintWriter out;

	boolean isFirst(String line){
		int pos = 0;
		while( pos<line.length() && Character.isLetter(line.charAt(pos))){
			pos++;
		}
		while( pos<line.length() && Character.isDigit(line.charAt(pos))){
			pos++;
		}
		return pos!=line.length();
		
	}
	
	void solve() {
		int n = in.nextInt();
		in.nextLine();
		for (int i = 1; i<=n; i++){
			String line = in.nextLine();
			line = line.toUpperCase();
			if (isFirst(line)){
				int pos = 1;
				long row = 0;
				while(Character.isDigit(line.charAt(pos))){
					row*=10;
					row+=line.charAt(pos)-'0';
					pos++;
				}
				pos++;
				long col = 0;
				while(pos<line.length() && Character.isDigit(line.charAt(pos))){
					col*=10;
					col+=line.charAt(pos)-'0';
					pos++;
				}
				StringBuilder sb = new StringBuilder();
				while(col>0){
					sb.append((char)('A'+((col-1)%26)));
					col--;
					col/=26;
				}
				sb = sb.reverse();
				out.print(sb);
				out.println(row);
				// ��������� � 1 �������
			}else{
				// ��������� �� 2 �������
				int pos = 0;
				long col = 0;
				while( pos<line.length() && Character.isLetter(line.charAt(pos))){
					col*=26;
					col+=line.charAt(pos)-'A'+1;
					pos++;
				}
				long row = 0;
				while(pos<line.length() && Character.isDigit(line.charAt(pos))){
					row*=10;
					row+=line.charAt(pos)-'0';
					pos++;
				}
				out.println("R"+row+"C"+col);
			}
		}

	}

	void run() {
		in = new Scanner(System.in);
		out = new PrintWriter(System.out);
		try {
			solve();
		} finally {
			out.close();
		}
	}

	public static void main(String[] args) {
		new Main().run();

	}

}
// Problem: 1_B. Spreadsheets
// Time complexity: linear
import java.io.FileNotFoundException;
import java.util.Scanner;

/**
 * Date: 19.02.2010
 * Time: 14:56:28
 *
 * @author Sergey Bankevich (Sergey.Bankevich@gmail.com)
 */
public class B1 {
    static Scanner in;

    public static void main( String[] args ) throws FileNotFoundException {
        in = new Scanner( System.in );
        int tn = in.nextInt();
        for ( int i = 0; i < tn; i ++ ) {
            String s = in.next();
        /*for ( int i = 1; i <= 100; i ++ ) {
            for ( int j = 1; j <= 100; j ++ ) {
                String s = "R" + i + "C" + j;
            for ( char j = 'A'; j <= 'Z'; j ++ ) {
            String s = j + "" + i;
                System.out.println( s );*/
            char[] c = s.toCharArray();
            boolean second = true;
            second &= c[0] == 'R';
            int r = s.indexOf( "C" );
            if ( r > 0 ) {
                second &= isNumber( s.substring( 1, r ) ) && isNumber( s.substring( r + 1 ) );
            } else {
                second = false;
            }
            if ( second ) {
                System.out.println( toLetters( s.substring( r + 1 ) ) + s.substring( 1, r ) );
            } else {
                r = 0;
                while ( c[r] >= 'A' && c[r] <= 'Z' ) {
                    r ++;
                }
                System.out.println( "R" + s.substring( r ) + "C" + fromLetters( s.substring( 0, r ) ) );
            }
             
        }
    }

    private static int fromLetters( String s ) {
        int r = 0;
        int l = s.length();
        for ( int i = 0; i < l; i ++ ) {
            r = r * 26 + s.charAt( i ) - 'A';
        }
        r ++;
        for ( int i = 1, c = 26; i < l; i ++, c *= 26 ) {
            r += c;
        }
        return r;
    }

    private static String toLetters( String s ) {
        int x = new Integer( s ) - 1;
        int c = 26;
        int l = 1;
        while ( true ) {
            if ( x < c ) {
                String r = "";
                for ( int i = 0; i < l; i ++ ) {
                    r = ( char ) ( 'A' + x % 26 ) + r;
                    x /= 26;
                }
                return r;
            }
            x -= c;
            c *= 26;
            l ++;
        }
    }

    private static boolean isNumber( String s ) {
        try {
            int x = new Integer( s );
        } catch ( NumberFormatException e ) {
            return false;
        }
        return true;
    }
}
// Problem: 1_B. Spreadsheets
// Time complexity: linear
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;
import java.util.HashMap;

public class B {

	/**
	 * @param args
	 * @throws IOException 
	 */
	static char[] digits = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'};
	static HashMap<Character, Integer> val = new HashMap<Character, Integer>();
	static HashMap<Integer, Character> ch = new HashMap<Integer, Character>();
	static StringBuffer strcol = new StringBuffer();
	static String s;
	
	static boolean isDigit(char a)
	{
		boolean found = false;
		for (int i = 0; i < digits.length; i++)
		{
			if (found = a == digits[i]) break;
		}
		
		return found;
	}
    static String ABtoRC(int pos)
	{
		do 
		{
			++pos; 
		} 
		while(!isDigit(s.charAt(pos)));
	
		int res = 0;
		for (int i = pos - 1, pow = 1; i >= 0; i--, pow *= 26) 
		{
			res += val.get(s.charAt(i)) * pow;
		}
		
		return new String("R" + s.substring(pos, s.length()) + "C" + String.valueOf(res));
	}
	
	static String RCtoAB(int cpos)
	{
		int col = Integer.valueOf(s.substring(cpos + 1, s.length()));
		int mod = 0;
		strcol.delete(0, strcol.length());
		
		while (col >= 26) 
		{
			int tmp = col / 26;
			mod = col - 26 * tmp;
			if (mod == 0) 
			{
				mod += 26;
				tmp -= 1;
				
			}
			col = tmp;
			strcol.append(ch.get(mod));
		}
		if(col != 0)strcol.append(ch.get(col));
		strcol.reverse();
		
		return strcol.toString() + s.substring(1, cpos); 
	}
	public static void main(String[] args) throws IOException 
	{
		// TODO Auto-generated method stub
//		BufferedReader input = new BufferedReader(new FileReader("input.txt"));
//		PrintWriter output = new PrintWriter(new FileWriter("output.txt"));
		BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
		PrintWriter output = new PrintWriter(new OutputStreamWriter(System.out));
		StreamTokenizer in = new StreamTokenizer(input);
		in.nextToken();
		int n = (int)in.nval;
		
		for (int i = 0; i < 26; i++) 
		{
			val.put((char)('A' + i), i + 1);
		}
		
		for (int i = 0; i < 26; i++) 
		{
			ch.put(i + 1, (char)('A' + i));
		}
		
		input.readLine();
		for (int i = 0; i < n; i++) {
			s = input.readLine();
			int cpos;
			if( ((cpos = s.indexOf('C')) > 1) && (isDigit(s.charAt(cpos - 1))) ) 
			{
				output.println(RCtoAB(cpos)); 
			}
			else
			{
				output.println(ABtoRC(cpos));
			}
		}
		
		output.close();
		input.close();
	}
}