codeparrot/codecomplex huggingface dataset:
// Problem: 908_C. New Year and Curling
// Time complexity: quadratic
import java.io.* ;
import java.util.* ;
import java.text.* ;
import java.math.* ;
import static java.lang.Math.min ;
import static java.lang.Math.max ;
import static java.lang.Math.sqrt ;
public class Codeshefcode{
	public static void main(String[] args) throws IOException{
		Solver Machine = new Solver() ;
		Machine.Solve() ;
		Machine.Finish() ;
		// new Thread(null,new Runnable(){
		// 	public void run(){
		// 		Solver Machine = new Solver() ;
		// 		try{
		// 			Machine.Solve() ;
		// 			Machine.Finish() ;
		// 		}catch(Exception e){
		// 			e.printStackTrace() ;
		// 			System.out.flush() ;
		// 			System.exit(-1) ;
		// 		}catch(Error e){
		// 			e.printStackTrace() ;
		// 			System.out.flush() ;
		// 			System.exit(-1) ;
		// 		}
		// 	}
		// },"Solver",1l<<27).start() ;
	}
}
class Mod{
	static long mod=1000000007 ;
	static long d(long a,long b){ return (a*MI(b))%mod ; }
	static long m(long a,long b){ return (a*b)%mod ; }
	static private long MI(long a){ return pow(a,mod-2) ; }
	static long pow(long a,long b){
		if(b<0) return pow(MI(a),-b) ;
		long val=a ; long ans=1 ;
		while(b!=0){
			if((b&1)==1) ans = (ans*val)%mod ; 
			val = (val*val)%mod ; 
			b/=2 ;
		}
		return ans ;
	}	
}
class pair implements Comparable<pair>{
	int x ; int y ; 
	pair(int x,int y){ this.x=x ; this.y=y ;} 
	public int compareTo(pair p){
		return (this.x<p.x ? -1 : (this.x>p.x ? 1 : (this.y<p.y ? -1 : (this.y>p.y ? 1 : 0)))) ;
	}
}
class Solver{
	Reader ip = new Reader(System.in) ;	  
	PrintWriter op = new PrintWriter(System.out) ;
	public void Solve() throws IOException{
		int n = ip.i() ; int r = ip.i() ;
		double x[] = new double[n] ;
		double y[] = new double[n] ;
		for(int i=0 ; i<n ; i++) x[i] = ip.i() ;
		for(int i=0 ; i<n ; i++){
			double my = 0 ;
			for(int j=0 ; j<i ; j++)
				my = max(my,func(x[j],y[j],r,x[i])) ;
			y[i] = my ;
		}
		for(int i=0 ; i<n ; i++) p((y[i]+r)+" ") ;
		pln("") ; 
	}
	double abd(double x,double y){
		return x>y ? x-y : y-x ;
	}
	double func(double x1,double y1,double r,double x2){
		if(abd(x1,x2)>(2*r)) return 0 ;
		if(abd(x1,x2)==(2*r)) return y1 ;
		double dx = x1-x2 ; 
		double dx2 = dx*dx ; 
		double val = sqrt(4*r*r-dx2) ;
		return y1+val ;
	}
	void Finish(){
		op.flush();
		op.close();
	}
	void p(Object o){
		op.print(o) ;
	}
	void pln(Object o){
		op.println(o) ;
	}		
}
class mylist extends ArrayList<Integer>{}
class myset extends TreeSet<Integer>{}
class mystack extends Stack<Integer>{}
class mymap extends TreeMap<Long,Integer>{}
class Reader{
	BufferedReader reader;
	StringTokenizer tokenizer;
	Reader(InputStream input) {
		reader = new BufferedReader(
					new InputStreamReader(input) );
		tokenizer = new StringTokenizer("") ;
	}
	String s() throws IOException {
		while (!tokenizer.hasMoreTokens()){
			tokenizer = new StringTokenizer(
			reader.readLine()) ;
		}
		return tokenizer.nextToken();
	}
	int i() throws IOException {
		return Integer.parseInt(s()) ;
	}
	long l() throws IOException{
		return Long.parseLong(s()) ;
	}
	double d() throws IOException {
		return Double.parseDouble(s()) ;
	}
}
// Problem: 908_C. New Year and Curling
// Time complexity: quadratic
import java.io.*;
import java.util.*;
import java.math.BigInteger;
import java.util.Map.Entry;

import static java.lang.Math.*;

public class C extends PrintWriter {

    void run() {

        int n = nextInt();
        int r = nextInt();
        int[] x = nextArray(n);

        double[] y = new double[n];
        Arrays.fill(y, r);

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < i; j++) {
                int dx = abs(x[i] - x[j]);
                int sdy = 4 * r * r - dx * dx;

                if (sdy >= 0) {
                    double dy = sqrt(sdy);
                    y[i] = max(y[i], y[j] + dy);
                }
            }
        }

        for (double v : y) {
            printf(Locale.ENGLISH, "%.10f ", v);
        }

    }

    boolean skip() {
        while (hasNext()) {
            next();
        }
        return true;
    }

    int[][] nextMatrix(int n, int m) {
        int[][] matrix = new int[n][m];
        for (int i = 0; i < n; i++)
            for (int j = 0; j < m; j++)
                matrix[i][j] = nextInt();
        return matrix;
    }

    String next() {
        while (!tokenizer.hasMoreTokens())
            tokenizer = new StringTokenizer(nextLine());
        return tokenizer.nextToken();
    }

    boolean hasNext() {
        while (!tokenizer.hasMoreTokens()) {
            String line = nextLine();
            if (line == null) {
                return false;
            }
            tokenizer = new StringTokenizer(line);
        }
        return true;
    }

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

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

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

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

    String nextLine() {
        try {
            return reader.readLine();
        } catch (IOException err) {
            return null;
        }
    }

    public C(OutputStream outputStream) {
        super(outputStream);
    }

    static BufferedReader reader;
    static StringTokenizer tokenizer = new StringTokenizer("");
    static Random rnd = new Random();
    static boolean OJ;

    public static void main(String[] args) throws IOException {
        OJ = System.getProperty("ONLINE_JUDGE") != null;
        C solution = new C(System.out);
        if (OJ) {
            reader = new BufferedReader(new InputStreamReader(System.in));
            solution.run();
        } else {
            reader = new BufferedReader(new FileReader(new File(C.class.getName() + ".txt")));
            long timeout = System.currentTimeMillis();
            while (solution.hasNext()) {
                solution.run();
                solution.println();
                solution.println("----------------------------------");
            }
            solution.println("time: " + (System.currentTimeMillis() - timeout));
        }
        solution.close();
        reader.close();
    }
}
// Problem: 908_C. New Year and Curling
// Time complexity: quadratic
import java.lang.*;
import java.io.*;
import java.util.*;

public class Main {


    public void solve() throws IOException {
        int n = nextInt(), r = nextInt();
        int x[] = new int[n];
        for (int i = 0; i < n; i++) {
            x[i] = nextInt();
        }
        double res[] = new double[n];
        res[0] = r;
        for (int i = 1; i < n; i++) {
            double max = r;
            for (int j = 0; j < i; j++) {
                int d = Math.abs(x[i] - x[j]);
                if(d <= 2 * r){
                    double yy = Math.sqrt(4 * r * r - d * d);
                    max = Math.max(max, yy + res[j]);
                }
            }
            res[i] = max;
        }
        for (int i = 0; i < n; i++) {
            out.print(res[i] + " ");
        }
    }

    BufferedReader br;
    StringTokenizer sc;
    PrintWriter out;

    public static void main(String[] args) throws IOException {
        Locale.setDefault(Locale.US);
        new Main().run();
    }

    void run() throws IOException {
        try {
            br = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
//            br = new BufferedReader(new FileReader("pnumbers.in"));
//            out = new PrintWriter(new File("out.txt"));
            solve();
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(1);
        }
    }

    String nextToken() throws IOException {
        while (sc == null || !sc.hasMoreTokens()) {
            try {
                sc = new StringTokenizer(br.readLine());
            } catch (Exception e) {
                return null;
            }
        }
        return sc.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());
    }

}
// Problem: 908_C. New Year and Curling
// Time complexity: quadratic
import java.io.*;
import java.util.*;
public class CC {
	public static void main(String[] args)throws Throwable {
		MyScanner sc=new MyScanner();
		PrintWriter pw=new PrintWriter(System.out);
		
		int n=sc.nextInt();
		int r=sc.nextInt();
		int [] x=new int [n];
		for(int i=0;i<n;i++)
			x[i]=sc.nextInt();
		double [] ans=new double [n];
		ans[0]=r;
		for(int i=1;i<n;i++){
			ans[i]=r;
			for(int j=0;j<i;j++){
				double dx=Math.abs(x[i]-x[j]);
				if(dx>2*r)
					continue;
				double y=Math.sqrt((4*r*r)-(dx*dx));
				ans[i]=Math.max(ans[i], ans[j]+y);
			}
		}
		
		
		for(double z : ans)
			pw.print(z+" ");
		pw.flush();
		pw.close();
	}
	
	static class MyScanner {
		BufferedReader br;
		StringTokenizer st;
		public MyScanner() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}
		String next() {while (st == null || !st.hasMoreElements()) {
			try {st = new StringTokenizer(br.readLine());}
			catch (IOException e) {e.printStackTrace();}}
		return st.nextToken();}
		int nextInt() {return Integer.parseInt(next());}
		long nextLong() {return Long.parseLong(next());}
		double nextDouble() {return Double.parseDouble(next());}
		String nextLine(){String str = "";
		try {str = br.readLine();}
		catch (IOException e) {e.printStackTrace();}
		return str;}
	}
}
// Problem: 908_C. New Year and Curling
// Time complexity: quadratic

public class Main {

	private static void solve() {
		int n = ni();
		double r = ni();

		double[][] p = new double[n][2];
		double EPS = 0.0000000000001;

		for (int i = 0; i < n; i ++) {
			double x = ni();
			double y = r;
			for (int j = 0; j < i; j ++) {
				double dx = Math.abs(p[j][0] - x);
				if (dx <= r * 2 + EPS) {
					double dy = Math.sqrt(4.0 * r * r - dx * dx);
					y = Math.max(y, p[j][1] + dy);
				}
			}
			out.printf("%.12f ", y);
			p[i][0] = x;
			p[i][1] = y;
		}
		out.println();
	}

	public static void main(String[] args) {
		new Thread(null, new Runnable() {
			@Override
			public void run() {
				long start = System.currentTimeMillis();
				String debug = args.length > 0 ? args[0] : null;
				if (debug != null) {
					try {
						is = java.nio.file.Files.newInputStream(java.nio.file.Paths.get(debug));
					} catch (Exception e) {
						throw new RuntimeException(e);
					}
				}
				reader = new java.io.BufferedReader(new java.io.InputStreamReader(is), 32768);
				solve();
				out.flush();
				tr((System.currentTimeMillis() - start) + "ms");
			}
		}, "", 64000000).start();
	}

	private static java.io.InputStream is = System.in;
	private static java.io.PrintWriter out = new java.io.PrintWriter(System.out);
	private static java.util.StringTokenizer tokenizer = null;
	private static java.io.BufferedReader reader;

	public static String next() {
		while (tokenizer == null || !tokenizer.hasMoreTokens()) {
			try {
				tokenizer = new java.util.StringTokenizer(reader.readLine());
			} catch (Exception e) {
				throw new RuntimeException(e);
			}
		}
		return tokenizer.nextToken();
	}

	private static double nd() {
		return Double.parseDouble(next());
	}

	private static long nl() {
		return Long.parseLong(next());
	}

	private static int[] na(int n) {
		int[] a = new int[n];
		for (int i = 0; i < n; i++)
			a[i] = ni();
		return a;
	}

	private static char[] ns() {
		return next().toCharArray();
	}

	private static long[] nal(int n) {
		long[] a = new long[n];
		for (int i = 0; i < n; i++)
			a[i] = nl();
		return a;
	}

	private static int[][] ntable(int n, int m) {
		int[][] table = new int[n][m];
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < m; j++) {
				table[i][j] = ni();
			}
		}
		return table;
	}

	private static int[][] nlist(int n, int m) {
		int[][] table = new int[m][n];
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < m; j++) {
				table[j][i] = ni();
			}
		}
		return table;
	}

	private static int ni() {
		return Integer.parseInt(next());
	}

	private static void tr(Object... o) {
		if (is != System.in)
			System.out.println(java.util.Arrays.deepToString(o));
	}
}
// Problem: 908_C. New Year and Curling
// Time complexity: quadratic
import java.util.*;
import java.io.*;

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

		StringTokenizer st = new StringTokenizer(sc.nextLine());
		int n = Integer.parseInt(st.nextToken());
		int r = Integer.parseInt(st.nextToken());

		ArrayList<Integer> centers = new ArrayList<Integer>();
		st = new StringTokenizer(sc.nextLine());
		for (int i = 0; i < n; i++) {
			centers.add(Integer.parseInt(st.nextToken()));
		}
		sc.close();
		ArrayList<Point> finalpoints = new ArrayList<Point>();
		for (int i = 0; i < n; i++) {
			double maxy = r;
			for (int j = 0; j < finalpoints.size(); j++) {
				if (finalpoints.get(j).x - centers.get(i) > 2 * r || centers.get(i) - finalpoints.get(j).x > 2 * r)
					continue;
				double dist = Math.sqrt(
						4 * r * r - (finalpoints.get(j).x - centers.get(i)) * (finalpoints.get(j).x - centers.get(i)))
						+ finalpoints.get(j).y;
				if(dist > maxy)
					maxy = dist;
			}
			
			pw.print(maxy + " ");
			finalpoints.add(new Point(centers.get(i), maxy));
		}
		
		pw.close();
	}

	public static class Point {
		double x;
		double y;

		public Point(double x, double y) {
			this.x = x;
			this.y = y;
		}
	}
}
// Problem: 908_C. New Year and Curling
// Time complexity: quadratic

import java.util.*;

public class Main {
    public static void main(String[] args) {
    	Scanner in=new Scanner(System.in);  
    	int n=in.nextInt(),r=in.nextInt();
    	double[] x=new double[n];
    	for(int i=0; i<n; i++)
    		x[i]=in.nextInt();
    	double[] y=new double[n];
    	for(int i=0; i<n; i++)
    	{
    		y[i]=r;
    		for(int j=0; j<i; j++)
    		{
    			
    			if(Math.abs(x[j]-x[i])<=2*r)
    			{
    				y[i]=Math.max(y[i], y[j]+Math.sqrt(4*r*r-(x[i]-x[j])*(x[i]-x[j])));
    			}
    		}
    	}
    	for(int i=0; i<n; i++)
    		System.out.print(y[i]+" ");
    }    
}
// Problem: 908_C. New Year and Curling
// Time complexity: quadratic
import java.io.*;
import java.util.HashSet;
import java.util.StringTokenizer;


public class GB_A {
    FastScanner in;
    PrintWriter out;

    public static void main(String[] arg) {
        new GB_A().run();
    }

    public void solve() throws IOException {
        int n = in.nextInt();
        int r = in.nextInt();
        int[] a = new int[n];
        double[] ans = new double[n];
        a[0] = in.nextInt();
        ans[0] = r;
        for (int i = 1; i < n; i++) {
            a[i] = in.nextInt();
            double max = r;
            for (int j = i - 1; j >= 0; j--) {
                if (Math.abs(a[i] - a[j]) <= 2 * r) {
                    double d = Math.sqrt(4 * r * r - (a[i]- a[j]) * (a[i] - a[j])) + ans[j];
                    max = Math.max(max, d);
                }

            }
            ans[i] = max;
        }
        for (int i = 0; i < n; i++) {
            out.println(ans[i]);
        }
    }


    public void run() {
        try {
            in = new FastScanner(new BufferedReader(new InputStreamReader(System.in)));
            out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));

            solve();

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

    class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        FastScanner(BufferedReader bufferedReader) {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !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());
        }

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



    }
}
// Problem: 908_C. New Year and Curling
// Time complexity: quadratic
import java.io.*;
import java.util.*;
	
public class Codeforces908C {
	public static void main(String[] args) throws IOException {
		BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(f.readLine());
		int n = Integer.parseInt(st.nextToken());
		int r = Integer.parseInt(st.nextToken());
		int[] x = new int[n];
		st = new StringTokenizer(f.readLine());
		for(int i = 0; i < n; i++) {
			x[i] = Integer.parseInt(st.nextToken());
		}
		double[] y = new double[n];
		y[0] = r;
		double hypSq = 4*r*r;
		for(int i = 1; i < n; i++) {
			boolean hit = false;
			double maxY = 0;
			for(int j = 0; j < i; j++) {
				int dx = Math.abs(x[i] - x[j]);
				if(dx == 2*r) {
					if(y[j] > maxY) {
						maxY = y[j];
						hit = true;
					}
				} else if(dx < 2*r) {
					double newY = y[j] + Math.sqrt(hypSq - dx*dx);
					if(newY > maxY) {
						maxY = newY;
						hit = true;
					}
				}
			}
			if(!hit) {
				y[i] = r;
			} else {
				y[i] = maxY;
			}
		}
		StringBuffer s = new StringBuffer("");
		for(int i = 0; i < n; i++) {
			s.append(y[i] + " ");
		}
		System.out.println(s.toString().trim());
	}
}
// Problem: 908_C. New Year and Curling
// Time complexity: quadratic
import java.util.*;

public class PC1229 {

	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int r = sc.nextInt();
		int[] x = new int[n];
		for(int i = 0; i < n; i++){
			x[i] = sc.nextInt();
		}
		double[] ans = new double[n];
		for(int i = 0; i < n; i++){
			double maxY = r;
			for(int j = 0; j < i; j++){
				if(x[j] <= x[i] + 2*r && x[j] >= x[i] - 2*r){
					maxY = Math.max(maxY, ans[j] + Math.sqrt(4 * r * r - (Math.abs(x[i] - x[j])) * (Math.abs(x[i] - x[j]))));
				}
			}
			ans[i] = maxY;
		}
		for(int i = 0; i < n; i++){
			System.out.println(ans[i]);
		}
		sc.close();
	}
	
}
// Problem: 908_C. New Year and Curling
// Time complexity: quadratic
import java.util.Scanner;

public class C {
  public static void main (String args[]) {
    Scanner in = new Scanner(System.in);
    
    int n = in.nextInt();
    int r = in.nextInt();
    
    double pos[][] = new double[n][2];
    
    for(int i = 0; i < n; i++) {
    	
    	pos[i][0] = in.nextInt();
    	
    	double y = r;
    	
    	for(int j = 0; j < i; j++) {
    		if(Math.abs(pos[i][0] - pos[j][0]) <= 2*r) {
    			
    			double tempy = pos[j][1] + Math.sqrt(Math.pow(2*r, 2) - Math.pow(Math.abs(pos[i][0] - pos[j][0]), 2));
    			
    			if(tempy > y) y = tempy;
    		}
    	}
    	
    	pos[i][1] = y;
    	System.out.print(y + " ");
    }
  }
}
// Problem: 908_C. New Year and Curling
// Time complexity: quadratic
import java.util.*;
import java.io.*;
import java.lang.*;
import java.math.*;

public class C {
	static double ycoord(double xi, double yi, double xj, double r) {
		if(Math.abs(xi-xj) > 2*r) return r;
		double dist = Math.sqrt((4*r*r)-((xi-xj)*(xi-xj)));
		//System.out.println("dist" + dist);
		return Math.max(yi+dist, r); //yi - dist?
	}
	public static void main(String[] args) throws Exception {
		FastScanner sc = new FastScanner();
		PrintWriter out = new PrintWriter(System.out);
		int n = sc.nextInt();
		double r = sc.nextInt();
		double[] xcoords = new double[n];
		double[] ycoords = new double[n];
		Arrays.fill(ycoords, Integer.MIN_VALUE);
		ycoords[0] = r;
		for(int i = 0; i < n; i++) {
			xcoords[i] = sc.nextDouble();
		}
		System.out.print(r + " ");
		for(int i = 1; i < n; ++i) {
			for(int j = 0; j < i; j++) {
				ycoords[i] = Math.max(ycoord(xcoords[j], ycoords[j],xcoords[i],r),ycoords[i]);
			}
			System.out.print(ycoords[i] + " ");
		}
		out.flush();
	}

	static class FastScanner {
		public BufferedReader reader;
		public StringTokenizer tokenizer;

		public FastScanner() {
			reader = new BufferedReader(new InputStreamReader(System.in), 32768);
			tokenizer = null;
		}

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

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

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

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

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

	}
}
// Problem: 908_C. New Year and Curling
// Time complexity: quadratic
//package info.stochastic;

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

public class C {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskC {

        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int n = in.nextInt();
            int r = in.nextInt();

            int x[] = new int[n];
            for (int i = 0; i < n; i++) {
                x[i] = in.nextInt();
            }

            double ans[] = new double[n];
            ans[0] = r;
            int index = 1;

            for (int i = 1; i < n; i++) {
                double maxY = r;
                for (int j = 0; j < index; j++) {
                    int xDist = Math.abs(x[i] - x[j]);
                    if (xDist <= r * 2) {
                        double cur = Math.sqrt((r * 2)*(r * 2) - xDist * xDist) + ans[j];
                        //out.println(cur);
                        maxY = Math.max(maxY, cur);
                    }
                }
                //out.println();
                ans[i] = maxY;
                index++;
            }

            for (int i = 0; i < n; i++) {
                out.print(ans[i] + " ");
            }

        }
    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

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

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