codeparrot/codecomplex huggingface dataset:
// Problem: 15_A. Cottage Village
// Time complexity: nlogn
import java.io.*;
import java.util.Arrays;
import java.util.StringTokenizer;

public class CodeForces {

	public void solve() throws IOException {
		int n=nextInt();
		int t=nextInt();
		double larr[]=new double [n];
		double rarr[]=new double [n];		
		for(int i=0;i<n;i++){
			double x=nextDouble();
			double r=nextDouble();
			larr[i]=x-r/2;
			rarr[i]=x+r/2;
		}
		Arrays.sort(larr);
		Arrays.sort(rarr);
		
		int counter=2;
		for(int i=1;i<n;i++){
			if(larr[i]-rarr[i-1]>t){
				counter+=2;
			} else if(larr[i]-rarr[i-1]==t){
				counter++;
			}
		}
		
		writer.print(counter);
	}

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

	BufferedReader reader;
	StringTokenizer tokenizer;
	PrintWriter writer;

	public void run() {
		try {
			reader = new BufferedReader(new InputStreamReader(System.in));
			//reader = new BufferedReader(new FileReader("input.txt"));
			tokenizer = null;
			writer = new PrintWriter(System.out);
			//writer = new PrintWriter(new BufferedWriter(new FileWriter("output.txt")));
			// long t=new Date().getTime();
			solve();
			// writer.println(t-new Date().getTime());
			reader.close();
			writer.close();
		} catch (Exception e) {
			e.printStackTrace();
			System.exit(1);
		}
	}

	int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}

	double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}

	String nextToken() throws IOException {
		while (tokenizer == null || !tokenizer.hasMoreTokens()) {
			tokenizer = new StringTokenizer(reader.readLine());
		}
		return tokenizer.nextToken();
	}
}
// Problem: 15_A. Cottage Village
// Time complexity: nlogn
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Locale;
import java.util.StringTokenizer;

public class Solution implements Runnable {
	
	public static void main(String[] args) {
		(new Thread(new Solution())).start();
	}
	
	BufferedReader in;
	PrintWriter out;
	StringTokenizer st;
	
	String nextToken() throws IOException {
		while (st == null || !st.hasMoreTokens()) st = new StringTokenizer(in.readLine());
		return st.nextToken();
	}
	
	int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}
	
	long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}
	
	double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}
	
	class Dom implements Comparable<Dom>{
		int x, a;

		public int compareTo(Dom o) {
			return x - o.x;
		}
	}
	
	void solve() throws Exception {
		int n = nextInt();
		int t = nextInt() * 2;
		Dom[] a = new Dom[n];
		for (int i = 0; i < n; i++) {
			a[i] = new Dom();
			a[i].x = nextInt() * 2;
			a[i].a = nextInt();
		}
		Arrays.sort(a);
		int ans = 2;
		for (int i = 0; i < n - 1; i++) {
			if (t < a[i + 1].x - a[i + 1].a - a[i].x - a[i].a) ans += 2;
			if (t == a[i + 1].x - a[i + 1].a - a[i].x - a[i].a) ans += 1;
		}
		out.print(ans);
	}
	
	public void run() {
		try {
			Locale.setDefault(Locale.US);
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(System.out);
			solve();
		} catch (Exception e) {
			e.printStackTrace();
		}
		out.flush();
	}

}
// Problem: 257_A. Sockets
// Time complexity: nlogn
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Scanner;

public class Sockets {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out);

        int n = in.nextInt(), m = in.nextInt(), socket = in.nextInt();
        int[] filters = new int[n];

        for (int i = 0; i < n; i++ ) {
            filters[i] = in.nextInt();
        }
        Arrays.sort(filters);

        int result = 0, index = n - 1;
        while ( m > socket && index >= 0) {
            socket += filters[index] - 1;
            result += 1;
            index -= 1;
        }

        out.println(m > socket ? -1 : result);
        out.close();
    }
}
// Problem: 257_A. Sockets
// Time complexity: nlogn
import java.io.*;
import java.math.BigInteger;
import java.util.*;

public class A
{
	String line;
	StringTokenizer inputParser;
	BufferedReader is;
	FileInputStream fstream;
	DataInputStream in;
	String FInput="";
	
	void openInput(String file)
	{

		if(file==null)is = new BufferedReader(new InputStreamReader(System.in));//stdin
		else
		{
			try{
		
				
			fstream = new FileInputStream(file);
			in = new DataInputStream(fstream);
			is = new BufferedReader(new InputStreamReader(in));
			}catch(Exception e)
			{
				System.err.println(e);
			}
		}

	}
	
	void readNextLine()
	{
		try {
			line = is.readLine();
			inputParser = new StringTokenizer(line, " ");
			//System.err.println("Input: " + line);
		} catch (IOException e) {
			System.err.println("Unexpected IO ERROR: " + e);
		}	
		catch (NullPointerException e)
		{
			line=null;
			
		}
		
	}
	
	int NextInt()
	{
		String n = inputParser.nextToken();
		int val = Integer.parseInt(n);
		
		//System.out.println("I read this number: " + val);
		return val;
	}
	
	long NextLong()
	{
		String n = inputParser.nextToken();
		long val = Long.parseLong(n);
		
		//System.out.println("I read this number: " + val);
		return val;
	}
	
	String NextString()
	{
		String n = inputParser.nextToken();
		return n;
	}
	
	void closeInput()
	{
		try {
			is.close();
		} catch (IOException e) {
			System.err.println("Unexpected IO ERROR: " + e);
		}
			
	}
	
	
	public static void main(String [] argv)
	{
		//String filePath="input.txt";
		//String filePath="D:\\_d\\learn\\coursera\\algorithms and design II\\data\\knapsack2.txt";
        String filePath=null;
		if(argv.length>0)filePath=argv[0];
		new A(filePath);
	}
	
	public void readFInput()
	{
		for(;;)
		{
			try
			{
				readNextLine();
				FInput+=line+" ";
			}
			catch(Exception e)
			{
				break;
			}
		}
		inputParser = new StringTokenizer(FInput, " ");
	}
	 
	public A(String inputFile)
	{
		openInput(inputFile);
		readNextLine();
		int N=NextInt(), M=NextInt(), K=NextInt();
		int [] v = new int[N];
		readNextLine();
		for(int i=0; i<N; i++)
		{
			
			v[i]=NextInt();
			
		}
		Arrays.sort(v);
		M-=(K-1);
		int id=N-1;
		int ret=0;
		while(M>1&&id>=0)
		{
			M++;
			M-=v[id--];
			ret++;
		}
		if(id<0&&M>1)ret=-1;
		System.out.println(ret);
		closeInput();			
	}
	

	public static void out(Object s)
	{
		try
		{
		    FileWriter fstream = new FileWriter("output.txt");
			BufferedWriter out = new BufferedWriter(fstream);
			out.write(s.toString());
			out.close();
		}catch (Exception e){
			System.err.println("Error: " + e.getMessage());
		}
	}
	

}
// Problem: 257_A. Sockets
// Time complexity: nlogn
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;


public class A {
    
    static StringTokenizer st;
    static BufferedReader in;
    public static void main(String[] args) throws IOException {
        in = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
        int n = nextInt();
        int m = nextInt();
        int k = nextInt();
        int[]a = new int[n+1];
        for (int i = 1; i <= n; i++) {
            a[i] = nextInt();
        }
        if (k >= m) {
            System.out.println(0);
            return;
        }
        Arrays.sort(a, 1, n+1);
        int ans = 0;
        for (int i = n; i >= 1; i--) {
            ans++;
            k--;
            k += a[i];
            if (k >= m) {
                System.out.println(ans);
                return;
            }
        }
        System.out.println(-1);
        pw.close();
    }
    private static int nextInt() throws IOException{
        return Integer.parseInt(next());
    }
    
    private static long nextLong() throws IOException{
        return Long.parseLong(next());
    }
    
    private static double nextDouble() throws IOException{
        return Double.parseDouble(next());
    }
    
    private static String next() throws IOException {
        while (st == null || !st.hasMoreTokens()) {
            st = new StringTokenizer(in.readLine());
        }
        return st.nextToken();
    }
}
// Problem: 257_A. Sockets
// Time complexity: nlogn
import java.util.*;
import java.io.*;

public class Sockets {

    BufferedReader in;
    PrintWriter out;
    StringTokenizer st;
    
    String nextToken() throws Exception {
        while (st == null || !st.hasMoreTokens()) st = new StringTokenizer(in.readLine());
        return st.nextToken();
    }
    
    int nextInt() throws Exception {
        return Integer.parseInt(nextToken());
    }
    
    void solve() throws Exception {
        int n = nextInt();
        int m = nextInt();
        int k = nextInt();
        List<Integer> fs = new ArrayList<Integer>();
        for (int i = 0; i < n; i++)
            fs.add(nextInt());
        Collections.sort(fs);
        Collections.reverse(fs);
        int c = k;
        for (int i = 0; i < fs.size(); i++) {
            if (c >= m) {
                out.println(i);
                return;
            }
            c += (fs.get(i)-1);
        }
        if (c>=m)
            out.println(fs.size());
        else
            out.println(-1);
    }
    
    void run() {
        try {
            in = new BufferedReader(new InputStreamReader(System.in));
//            in = new BufferedReader(new FileReader("input.txt"));
            out = new PrintWriter(System.out);
            solve();
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(1);
        } finally {
            out.close();
        }
    }
    
    public static void main(String[] args) {
        new Sockets().run();
    }

}
// Problem: 257_A. Sockets
// Time complexity: nlogn
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author c0der
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }
}

class TaskA {
    public void solve(int testNumber, InputReader in, PrintWriter out) {
        int n = in.nextInt();
        int m = in.nextInt();
        int k = in.nextInt();
        int[] a = new int[ n ];
        for (int i=0; i<n; i++) a[i] = in.nextInt();

        if ( m <= k ) out.println( 0 );
        else
        {
            m -= k - 1;
            Arrays.sort( a );
            int ans = 0;
            for (int i=n-1; i>=0; i--)
            {
                ans++;
                //out.println(m+" "+a[i]);
                m -= a[ i ];
                if ( m <= 0 ) break;
                m++;
            }
            if ( m > 0 ) out.println( -1 );
            else out.println( ans );
        }
    }
}

class InputReader {
    BufferedReader br;
    StringTokenizer st;

    public InputReader(InputStream in)
    {
        br = new BufferedReader(new InputStreamReader(in));
        st = null;
    }

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

    public int nextInt()
    {
        return Integer.parseInt(next());
    }
}
// Problem: 257_A. Sockets
// Time complexity: nlogn
import java.io.*;
import java.util.*;

public class A {

	BufferedReader in;
	StringTokenizer st;
	PrintWriter out;

	String next() throws IOException {
		while (st == null || !st.hasMoreTokens())
			st = new StringTokenizer(in.readLine());
		return st.nextToken();
	}

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

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

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

	void solve() throws Exception {
		int n = nextInt(), k = nextInt(), s = nextInt();
		int a[] = new int[n];
		for (int i = 0; i < n; i++)
			a[i] = -nextInt();
		
		Arrays.sort(a);
		for(int i=0;i<n;i++)
		{
			if (s>=k)
			{
				out.println(i);
				return;
			}
			
			s += -a[i];
			s--;
		}
		if (s<k)
			out.println(-1);
		else
			out.println(n);
	}

	void run() {
		try {
			Locale.setDefault(Locale.US);
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(new OutputStreamWriter(System.out));
			solve();
			out.close();
		} catch (Exception e) {
			e.printStackTrace();
			System.exit(1);
		}
	}

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


}
// Problem: 257_A. Sockets
// Time complexity: nlogn
//package Round_159;

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

import static java.lang.Math.*;

public class a {

	void solve() throws Exception {
		int n = in.nextInt();
		int m = in.nextInt();
		int k = in.nextInt();
		int a[] = new int[n];
		for (int i = 0; i<n; i++){
			a[i] = in.nextInt();
		}
		Arrays.sort(a);
		int sum = 0;
		if (k >= m){
			out.println(0);
			return;
		}
		sum = a[n-1] + k - 1;
		int j = 1;
		for (int i = n-2; i >=0 && sum < m; i--, j++){
			sum += a[i] - 1;
		}
		if (sum < m){
			out.println(-1);
		}else{
			out.println(j);
		}
	}

	FastScanner in;
	PrintWriter out;

	String input = "";
	String output = "";

	void run() {
		try {
			if (input.length() > 0) {
				in = new FastScanner(new BufferedReader(new FileReader(input)));
			} else
				in = new FastScanner(new BufferedReader(new InputStreamReader(
						System.in)));
			if (output.length() > 0)
				out = new PrintWriter(new FileWriter(output));
			else
				out = new PrintWriter(System.out);

			solve();

			out.flush();
			out.close();
		} catch (Exception ex) {
			ex.printStackTrace();
			out.flush();
			out.close();
		} finally {
			out.close();
		}
	}

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

	class FastScanner {
		BufferedReader bf;
		StringTokenizer st;

		public FastScanner(BufferedReader bf) {
			this.bf = bf;
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(bf.readLine());
			return st.nextToken();
		}

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

		public String nextLine() throws IOException {
			return bf.readLine();
		}

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

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

	}

}
// Problem: 257_A. Sockets
// Time complexity: nlogn
import java.util.*;
import java.io.*;

public class Main {
    
    public static void main(String[] args) throws Exception {
        Scanner in = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out);
        
        int n = in.nextInt(), m = in.nextInt(), k = in.nextInt();
        int[] a = new int[n];
        for (int i = 0; i < n; i++) a[i] = in.nextInt();
        Arrays.sort(a);
        int ans = 0, r = k, p = n-1;
        while (r < m && p >= 0) {
            r = r - 1 + a[p];
            p--;
            ans++;
        }
        if (r < m) out.println("-1");
        else out.println(ans);
        
        out.flush();
    }
    
}
// Problem: 257_A. Sockets
// Time complexity: nlogn
import java.util.Arrays;
import java.util.Scanner;


public class Main {

    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        
        int n = s.nextInt();
        int m = s.nextInt();
        int k = s.nextInt();
        
        int a[] = new int [n];
        for (int i = 0; i < a.length; i++) {
            a[i] = s.nextInt();
        }
        int ans = 0;
        
        while(k < m){
            k--;
            int max = -1;
            int ix = -1;
            for (int i = 0; i < a.length; i++) {
                if(a[i] > max){
                    max = a[i];
                    ix = i;
                }
            }
            if(ix == -1){
                System.out.println("-1");
                return ;
            }
            k += a[ix];
            a[ix] = -1;
            ans++;
        }
        System.out.println(ans);
    }

}
// Problem: 257_A. Sockets
// Time complexity: nlogn
//package A;

import java.io.IOException;
import java.util.Arrays;
import java.util.Scanner;

public class Solution {
    public static void main(String args[]) throws IOException {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int m = in.nextInt();
        int k = in.nextInt();
        int[] a = new int[n];
        for (int i = 0; i < n; ++i)
            a[i] = in.nextInt();
        Arrays.sort(a);
        
        int res = 0, p = n - 1;
        while (k < m && p >= 0) {
            ++res;
            k += a[p] - 1;
            --p;
        }
        if (k >= m)
            System.out.println(res);
        else
            System.out.println("-1");
    }
}
// Problem: 257_A. Sockets
// Time complexity: nlogn
import java.util.Arrays;
import java.util.Scanner;

public class Main2 {
	
    public static void main(String args[]){
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        int m = input.nextInt();
        int k = input.nextInt();
        int[] num = new int[n];
        for(int i = 0 ; i < n ; i++){
        	num[i] = input.nextInt();
        }
        
        System.out.println(str(n,m,k,num));
    }

	static int str(int n,int m,int k,int[] num){
		Arrays.sort(num);
		int total = k;
		int count = 0;
		while(k < m){
			if(count == num.length)return -1;
			k += num[num.length-count-1]-1;
			count++;
		}
		return count;
	}
	
}
// Problem: 257_A. Sockets
// Time complexity: nlogn
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Main {
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String[] in = br.readLine().split(" ");
		
		int n=Integer.parseInt(in[0]),m=Integer.parseInt(in[1]),k=Integer.parseInt(in[2]);
		
		StringTokenizer st = new StringTokenizer(br.readLine());
		int[] caps = new int[n];
		for (int i = 0; i < caps.length; i++) {
			caps[i] = Integer.parseInt(st.nextToken());
		}
		Arrays.sort(caps);
		
		int curSockets=k, neededLines=0;
		int i = n-1;
		while(curSockets<m && i>=0){
			curSockets+=caps[i]-1;
			neededLines++;
			i--;
		}
		if(curSockets>=m)
			System.out.println(neededLines);
		else
			System.out.println(-1);
	}
}
// Problem: 257_A. Sockets
// Time complexity: nlogn
import java.io.*;
import java.util.*;
import java.lang.*;

public class Main {

  public static void main(String[] args) {
    Scanner cin=new Scanner(new BufferedInputStream(System.in));
    
    int n=cin.nextInt(),
        m=cin.nextInt(),
        k=cin.nextInt();
    int[] a=new int[51];
    
    for (int i=0;i<n;i++) {
      a[i]=-cin.nextInt();
    }
    Arrays.sort(a);
    
    if (m<=k) {
        System.out.println(0);
        return;
    }
    for (int i=0;i<Math.min(k,n);i++) {
      m+=a[i];
      if (m-(k-1-i)<=0) {
        System.out.println(i+1);
        return;
      }
    }
    for (int i=k;i<n;i++) {
      m+=a[i]+1;
      if (m<=0) {
        System.out.println(i+1);
        return;
      }
    }
    System.out.println(-1);
    
    cin.close();
  }

}
// Problem: 257_A. Sockets
// Time complexity: nlogn
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;

public class CFTest6 {

	static BufferedReader br;

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

		try {

			int[] a1 = readIntArr();
			int[] a2 = readIntArr();
			br.close();
			int f = a1[0];
			int d = a1[1];
			int s = a1[2];
			Arrays.sort(a2);

			if (d <= s)
				System.out.println(0);

			else {
				int cur = d - s + 1;

				
				int num=0;
				for(int i=0;i<f;i++){
					num++;
					cur-=a2[f-i-1];
					if(cur<=0)break;
					cur++;
				}
				if (cur > 0)
					System.out.println(-1);
				else{
					
				
					System.out.println(num);
				}
			}

		} catch (IOException e) {
			e.printStackTrace();
		}

	}

	static public String readLine() throws IOException {
		return br.readLine();

	}

	static public String readString() throws IOException {
		return br.readLine();

	}

	static public long readlong() throws IOException {
		return Long.parseLong(br.readLine());
	}

	static public int readInt() throws IOException {
		return Integer.parseInt(br.readLine());
	}

	static public int[] readIntArr() throws IOException {
		String[] str = br.readLine().split(" ");
		int arr[] = new int[str.length];
		for (int i = 0; i < arr.length; i++)
			arr[i] = Integer.parseInt(str[i]);
		return arr;
	}

	static public double[] readDoubleArr() throws IOException {
		String[] str = br.readLine().split(" ");
		double arr[] = new double[str.length];
		for (int i = 0; i < arr.length; i++)
			arr[i] = Double.parseDouble(str[i]);
		return arr;
	}

	static public long[] readLongArr() throws IOException {
		String[] str = br.readLine().split(" ");
		long arr[] = new long[str.length];
		for (int i = 0; i < arr.length; i++)
			arr[i] = Long.parseLong(str[i]);
		return arr;
	}

	static public double readDouble() throws IOException {
		return Double.parseDouble(br.readLine());
	}
}
// Problem: 257_A. Sockets
// Time complexity: nlogn
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.Arrays;
import java.util.Comparator;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.util.Collections;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskA solver = new TaskA();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskA {
    public void solve(int testNumber, InputReader in, PrintWriter out) {
        int n=in.nextInt();
        int m=in.nextInt();
        int k=in.nextInt();
        Integer []cap=new Integer[n];
        for(int i=0;i<n;i++) {
            cap[i]=in.nextInt();
        }
        Arrays.sort(cap, Collections.reverseOrder());
        int count=0;

        while(k<m && count<cap.length) {
            k+=(cap[count]-1);
            ++count;
        }
        if(k>=m) {
            out.println(count);
        } else {
            out.println(-1);
        }
    }
}

class InputReader {
    StringTokenizer st;
    BufferedReader in;
    public InputReader(InputStream ins)
    {
        in = new BufferedReader(new InputStreamReader(ins));
    }

    public String nextToken()
    {
        while(st==null || !st.hasMoreTokens())
        {
            try {
                st=new StringTokenizer(in.readLine());
            } catch (IOException e) {
                e.printStackTrace();  //To change body of catch statement use File | Settings | File Templates.
            }
        }
        return st.nextToken();
    }
    public int nextInt()
    {

        return Integer.parseInt(nextToken());
    }

    }