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

public class PetyaAndJava{
    public static void main(String[] args)throws IOException{
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
        BigInteger n = new BigInteger(in.readLine());
        if(new BigInteger("-129").compareTo(n) == -1 && n.compareTo(new BigInteger("128")) == -1 )
            out.println("byte");
        else if(new BigInteger("-32769").compareTo(n) == -1 && n.compareTo(new BigInteger("32768")) == -1 )
            out.println("short");
        else if(new BigInteger("-2147483649").compareTo(n) == -1 && n.compareTo(new BigInteger("2147483648")) == -1 )
            out.println("int");
        else if(new BigInteger("-9223372036854775809").compareTo(n) == -1 && n.compareTo(new BigInteger("9223372036854775808")) == -1 )
            out.println("long");
        else
            out.println("BigInteger");
        out.close();
    }
}

import java.io.*;
import java.math.BigInteger;
import java.util.*;
public class codeforces {
    static class pair{
        int x;
        int y;

        public pair(int x,int y){
            this.x=x;
            this.y=y;
        }
    }

    public static long sqrt(long x){
        long s=0,e=x,root=0;
        while(s<=e){
            long mid=(s+e)/2;
            if(mid*mid==x)
            return mid;
            if(mid*mid<x)
            {
                root=mid;
                s=mid+1;
            }
            else
                e=mid-1;
        }
        return root;
    }

    public static long power(int a,int b){
        if(a==0 || b==0)
        return 1;
        long ans=power(a,b/2);
        ans*=ans;
        if(b%2==1)
        ans*=a;
        return ans;
    }

    public static boolean isprime(int x){
        if(x==1)return false;
        if(x<4)return true;
        int root=(int) Math.sqrt(x);
        for(int i=2;i<=root;i++){
            if(x%i==0)
            return false;
        }
        return true;
    }

    public static int max(int a,int b){
        return Math.max(a,b);
    }

    public static int min(int a,int b){
        return Math.min(a,b);
    }

    public static void main(String args[] ) throws IOException {
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        StringBuilder str=new StringBuilder();
        PrintWriter out=new PrintWriter(System.out);
        String a=br.readLine();
        BigInteger bigInteger=new BigInteger(a);
        if(a.charAt(0)=='-'){
            if(bigInteger.compareTo(BigInteger.valueOf(Long.MIN_VALUE))<0)
            out.println("BigInteger");
            else
            if(Long.parseLong(a)-Integer.MIN_VALUE<0)
            out.println("long");
            else
            if(Integer.parseInt(a)-Short.MIN_VALUE<0)
            out.println("int");
            else
            if(Short.parseShort(a)-Byte.MIN_VALUE<0)
            out.println("short");
            else
            out.println("byte");
        }
        else{
            if(bigInteger.compareTo(BigInteger.valueOf(Long.MAX_VALUE))>0)
            out.println("BigInteger");
            else
            if(Long.parseLong(a)-Integer.MAX_VALUE>0)
            out.println("long");
            else
            if(Integer.parseInt(a)-Short.MAX_VALUE>0)
            out.println("int");
            else
            if(Short.parseShort(a)-Byte.MAX_VALUE>0)
            out.println("short");
            else
            out.println("byte");
        }
        out.close();
   }
}

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

public class Main
{
	public static void main( String[] args )
	{
		Scan scan=new Scan();
		PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out));
		BigInteger x=scan.nextBigInteger();
		String ans;
		if(new BigInteger("-128").compareTo(x)<=0 && x.compareTo(new BigInteger("127"))<=0)
			ans="byte";
		else if(new BigInteger("-32768").compareTo(x)<=0 && x.compareTo(new BigInteger("32767"))<=0)
			ans="short";
		else if(new BigInteger("-2147483648").compareTo(x)<=0 && x.compareTo(new BigInteger("2147483647"))<=0)
			ans="int";
		else if(new BigInteger("-9223372036854775808").compareTo(x)<=0 && x.compareTo(new BigInteger("9223372036854775807"))<=0)
			ans="long";
		else
			ans="BigInteger";
		out.println(ans);
		out.close();
	}
}

class Scan
{
	BufferedReader br;
	StringTokenizer st;
	public Scan()
	{
		br = new BufferedReader( new InputStreamReader( System.in ) );
	}
	boolean hasNext()
	{
		while ( st == null ||  ! st.hasMoreElements() )
		{
			try
			{
				st = new StringTokenizer( br.readLine() );
			}
			catch ( Exception e )
			{
				return false;
			}
		}
		return true;
	}
	String next()
	{
		return hasNext() ? st.nextToken() : null;
	}
	int nextInt()
	{
		return hasNext() ? Integer.parseInt( st.nextToken() ) : -1;
	}
	long nextLong()
	{
		return hasNext() ? Long.parseLong( st.nextToken() ) : -1;
	}
	double nextDouble()
	{
		return hasNext() ? Double.parseDouble( st.nextToken() ) : -1;
	}
	BigInteger nextBigInteger()
	{
		return hasNext() ? new BigInteger( st.nextToken() ) : null;
	}
}

import java.util.*;
import java.util.LinkedList;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.math.BigInteger;

public class tmp {
    public static void main(String [] args) throws Exception{
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    //    StringTokenizer st = new StringTokenizer(in.readLine());
        StringBuilder sb = new StringBuilder();

        String s = in.readLine();

        int n = s.length();

        if(n < 3){
            System.out.println("byte");
        }else if(n == 3){
            System.out.println(s.compareTo("127") <= 0 ? "byte" : "short");
        }else if(n < 5){
            System.out.println("short");
        }else if(n == 5){
            System.out.println(s.compareTo("32767") <= 0  ? "short" : "int");
        }else if(n < 10){
            System.out.println("int");
        }else if(n == 10){
            System.out.println(s.compareTo("2147483647") <= 0  ? "int" : "long");
        }else if(n < 19){
            System.out.println("long");
        }else if(n == 19){
            System.out.println(s.compareTo("9223372036854775807") <= 0  ? "long" : "BigInteger");
        }else
            System.out.println("BigInteger");

    }

}

class P implements Comparable<P>{
    int val, idx;
    public P(int val, int idx){
        this.val = val;
        this.idx = idx;
    }

    public int compareTo(P other){
        if (this.val != other.val) return -this.val + other.val;
        return this.idx - other.idx;
    }
}

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

public class Main {

	public static void main(String[] args) throws Exception  {

		Scanner in = new Scanner(System.in);
		String n = in.nextLine();
		BigInteger bi = new BigInteger(n);

		BigInteger byteL = new BigInteger("-128");
		BigInteger byteH = new BigInteger("127");

		BigInteger shortL = new BigInteger("-32768");
		BigInteger shortH = new BigInteger("32767");

		BigInteger intL = new BigInteger("-2147483648");
		BigInteger intH = new BigInteger("2147483647");

		BigInteger longL = new BigInteger("-9223372036854775808");
		BigInteger longH = new BigInteger("9223372036854775807");

		BigInteger test = new BigInteger("5");
		BigInteger test2 = new BigInteger("3");

		if (bi.compareTo(byteL) >= 0 && bi.compareTo(byteH) <= 0){
			System.out.println("byte");
		}

		else if(bi.compareTo(shortL) >= 0 && bi.compareTo(shortH) <= 0){
			System.out.println("short");
		}
		else if(bi.compareTo(intL) >= 0 && bi.compareTo(intH) <= 0){
			System.out.println("int");
		}
		else if(bi.compareTo(longL) >= 0 && bi.compareTo(longH) <= 0){
			System.out.println("long");
		}
		else{
			System.out.println("BigInteger");
		}

	} // end of Main
} // end of class Main

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.StringTokenizer;

public class Main {
	static long	sum	= 0;
	static int	n;

	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) {
			String x = in.next();

			if(x.length()<= 18)
			{
				long i = Long.valueOf(x);
				if(i<=127 && i>=-128)
				{
					out.println("byte");
					return ;
				}
				if(i <=32767 && i>= -32768)
				{
					out.println("short");
					return ;
				}
				if(i <= 2147483647 && i>= -2147483648)
				{
					out.println("int") ;
					return ;
				}
				out.println("long");
				return ;
			}

			BigInteger i = new BigInteger(x) ;
			BigInteger i1 = new BigInteger("9223372036854775807") ;
			BigInteger i2 = new BigInteger("-9223372036854775808") ;

			if(i.compareTo(i1) >0    || i.compareTo(i2)<0 )
			{
				out.println("BigInteger");
				return;
			}
			out.println("long");
		}

		int binarySearch(Pair arr[], int l, int r, int x,int n)
		{
			if (r>=l)
			{
				int mid = l + (r - l)/2;
				if (arr[mid].audio <= x && ((mid+1)<=n-1 && arr[mid+1].audio>x))
					return mid+1;
				if (arr[mid].audio > x)
					return binarySearch(arr, l, mid-1, x,n);
				return binarySearch(arr, mid+1, r, x,n);
			}
			return r ;

		}

	}

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

	}

	static class Pair implements Comparable<Pair> {
		int index;
		int subtitle ;
		int audio ;

		public Pair(int index,int audio,int subtitle) {
			this.index = index;
			this.subtitle = subtitle;
			this.audio = audio;
		}

		@Override
		public int compareTo(Pair p) {
			if (this.audio < p.audio)
				return -1;
			else if (this.audio > p.audio)
				return 1;
			else
				if (this.subtitle < p.subtitle)
					return -1;
				else if (this.subtitle > p.subtitle)
					return 1;
			return 0;

		}
		//
	}

}

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

public class Main4 {

    public static void main(String args[]) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        // Scanner in = new Scanner(System.in);
        BigInteger b = new BigInteger(br.readLine());
//      BigInteger b = new BigInteger("10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000");

        if (b.compareTo(new BigInteger("-128")) >= 0
                && b.compareTo(new BigInteger("127")) <= 0) {
            System.out.println("byte");
        } else  if (b.compareTo(new BigInteger("-32768")) >= 0
                && b.compareTo(new BigInteger("32767")) <= 0) {
            System.out.println("short");
        } else if (b.compareTo(new BigInteger("-2147483648")) >= 0
                && b.compareTo(new BigInteger("2147483647")) <= 0) {
            System.out.println("int");
        }else if (b.compareTo(new BigInteger("-9223372036854775808")) >= 0
                && b.compareTo(new BigInteger("9223372036854775807")) <= 0) {
            System.out.println("long");
        }else{
            System.out.println("BigInteger");
        }
    }
}

import java.util.Scanner;

public class PetyaAndJava
{

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        try
        {
            long x=sc.nextLong();
            if (x>=-127 && x<=127)
            {
                System.out.println("byte");
            }
            else if (x>=-32768 && x<=32767)
            {
                System.out.println("short");
            }
            else if (x>=-2147483648  && x<=2147483647)
            {
                System.out.println("int");
            }
            else
                System.out.println("long");
        }
        catch(Exception e)
        {
            System.out.println("BigInteger");
        }

    }

}

import java.math.BigInteger;
import java.util.Scanner;

/**
 *
 * @author Ahmed
 */
public class PetyaAndJava {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        Scanner s=new Scanner(System.in);

       String z= s.next();

if(type(z))
{
            long x = Long.parseLong(z);

        if (x >= -128 &&  x <=127)
        {
            System.out.println("byte");
        }
       else if (x >= -32767 &&  x <= 32767)
        {
            System.out.println("short");
        }
       else if (x >= -2147483648  &&  x <=2147483647)
        {
            System.out.println("int");
        }
       else if (x >= -9223372036854775808l   &&  x <= 9223372036854775807l)
        {
            System.out.println("long");
        }
}
        else
            System.out.println("BigInteger");

    }
    public static boolean type (String l){
    try{
    long x = Long.parseLong(l);
    return true;

    }
    catch(Exception e){ return false ;}
    }
}

import java.math.BigInteger;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        BigInteger b = new BigInteger(sc.nextLine()) ;

        if (b.compareTo(new BigInteger ("-128")) > -1 && b.compareTo(new BigInteger ("127")) < 1)
            System.out.println("byte");
        else if (b.compareTo(new BigInteger ("-32768")) > -1 && b.compareTo(new BigInteger ("32767")) < 1)
            System.out.println("short");
        else if (b.compareTo(new BigInteger ("-2147483648")) > -1 && b.compareTo(new BigInteger ("2147483647")) < 1)
            System.out.println("int");
        else if (b.compareTo(new BigInteger ("-9223372036854775808")) > -1 && b.compareTo(new BigInteger ("9223372036854775807")) < 1)
            System.out.println("long");
        else
            System.out.println("BigInteger");

        sc.close();
    }

}

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

public class Solution {

    private BufferedReader in;
    private PrintWriter out;
    private StringTokenizer st;

    public String next() throws Exception {
        if (st == null || !st.hasMoreElements()) {
            st = new StringTokenizer(in.readLine());
        }
        return st.nextToken();
    }

    public int nextInt() throws Exception {
        return Integer.parseInt(next());
    }
    public long nextLong() throws Exception {
        return Long.parseLong(next());
    }
    public double nextDouble() throws Exception {
        return Double.parseDouble(next());
    }

    public void run() throws Exception {
        in = new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(System.out);
        String s = next();
        String b = "128";
        String sh = "32768";
        String in = "2147483648";
        String lo = "9223372036854775808";
        while(s.length() < 100) s = "0" + s;
        while(b.length() < 100) b = "0" + b;
        while(sh.length() < 100) sh = "0" + sh;
        while(in.length() < 100) in = "0" + in;
        while(lo.length() < 100) lo = "0" + lo;
        if (s.compareTo(b) < 0) {
            out.println("byte");
        } else if (s.compareTo(sh) < 0) {
            out.println("short");
        } else if (s.compareTo(in) < 0) {
            out.println("int");
        } else if (s.compareTo(lo) < 0) {
            out.println("long");
        } else {
            out.println("BigInteger");
        }
        out.close();
    }

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

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.math.BigInteger;

public class Binary1{

    static class FastScanner{
        BufferedReader s;
        StringTokenizer st;

        public FastScanner(){
            st = new StringTokenizer("");
            s = new BufferedReader(new InputStreamReader(System.in));

        }

        public FastScanner(File f) throws FileNotFoundException{
            st = new StringTokenizer("");
            s = new BufferedReader (new FileReader(f));
        }

        public int nextInt() throws IOException{
            if(st.hasMoreTokens())
                return Integer.parseInt(st.nextToken());
            else{
                st = new StringTokenizer(s.readLine());
                return nextInt();
            }
        }

        public double nextDouble() throws IOException{
            if(st.hasMoreTokens())
                return Double.parseDouble(st.nextToken());
            else{
                st = new StringTokenizer(s.readLine());
                return nextDouble();
            }
        }

        public long nextLong() throws IOException{
            if(st.hasMoreTokens())
                return Long.parseLong(st.nextToken());
            else{
                st = new StringTokenizer(s.readLine());
                return nextLong();
            }
        }

        public String nextString() throws IOException{
            if(st.hasMoreTokens())
                return st.nextToken();
            else{
                st = new StringTokenizer(s.readLine());
                return nextString();
            }

        }

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

        public void close() throws IOException{
            s.close();
        }

    }      //Fastscanner class end

   static FastScanner in=new FastScanner();
   static PrintWriter ww=new PrintWriter(new OutputStreamWriter(System.out));
   public static void main(String args[])throws IOException
   {
   //Main ob=new Main();
   Binary1 ob=new Binary1();
   ob.solve();
   ww.close();
   }
   public void solve()throws IOException
   {
     BigInteger i=new BigInteger(in.nextString());
     int bitCount=i.bitLength();
     if(bitCount<8)
        System.out.println("byte");
     else if(bitCount<16)
         System.out.println("short");
     else if(bitCount<32)
          System.out.println("int");
    else if(bitCount<64)
          System.out.println("long");
    else
          System.out.println("BigInteger");

  }
  }

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.math.BigInteger;

public class Binary2{

    static class FastScanner{
        BufferedReader s;
        StringTokenizer st;

        public FastScanner(){
            st = new StringTokenizer("");
            s = new BufferedReader(new InputStreamReader(System.in));

        }

        public FastScanner(File f) throws FileNotFoundException{
            st = new StringTokenizer("");
            s = new BufferedReader (new FileReader(f));
        }

        public int nextInt() throws IOException{
            if(st.hasMoreTokens())
                return Integer.parseInt(st.nextToken());
            else{
                st = new StringTokenizer(s.readLine());
                return nextInt();
            }
        }

        public double nextDouble() throws IOException{
            if(st.hasMoreTokens())
                return Double.parseDouble(st.nextToken());
            else{
                st = new StringTokenizer(s.readLine());
                return nextDouble();
            }
        }

        public long nextLong() throws IOException{
            if(st.hasMoreTokens())
                return Long.parseLong(st.nextToken());
            else{
                st = new StringTokenizer(s.readLine());
                return nextLong();
            }
        }

        public String nextString() throws IOException{
            if(st.hasMoreTokens())
                return st.nextToken();
            else{
                st = new StringTokenizer(s.readLine());
                return nextString();
            }

        }

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

        public void close() throws IOException{
            s.close();
        }

    }      //Fastscanner class end

   static FastScanner in=new FastScanner();
   static PrintWriter ww=new PrintWriter(new OutputStreamWriter(System.out));
   public static void main(String args[])throws IOException
   {
   //Main ob=new Main();
   Binary2 ob=new Binary2();
   ob.solve();
   ww.close();
   }
   public void solve()throws IOException
   {
     BigInteger i=new BigInteger(in.nextString());
     BigInteger by=new BigInteger("127");
     BigInteger sh=new BigInteger("32767");
     BigInteger in=new BigInteger("2147483647");
     BigInteger lo=new BigInteger("9223372036854775807");
     if(i.compareTo(lo)>0)
           System.out.println("BigInteger");
     else if(i.compareTo(in)>0)
            System.out.println("long");
     else if(i.compareTo(sh)>0)
            System.out.println("int");
     else if(i.compareTo(by)>0)
             System.out.println("short");
     else
           System.out.println("byte");

  }
  }

import java.math.BigInteger;
import java.util.Scanner;

public class P66A_PetyaAndJava {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		String input = scanner.nextLine();
		scanner.close();

		String[] types = { "byte", "short", "int", "long" };
		BigInteger[] upperBounds = { BigInteger.valueOf(127),
				BigInteger.valueOf(32767), BigInteger.valueOf(2147483647),
				BigInteger.valueOf(9223372036854775807L) };
		BigInteger[] lowerBounds = { BigInteger.valueOf(-128),
				BigInteger.valueOf(-32768), BigInteger.valueOf(-2147483648),
				BigInteger.valueOf(-9223372036854775808L) };
		BigInteger number = new BigInteger(input);

		for (int i = 0; i < lowerBounds.length; i++) {
			if (number.compareTo(lowerBounds[i]) >= 0
					&& number.compareTo(upperBounds[i]) <= 0) {
				System.out.println(types[i]);
				return;
			}
		}

		System.out.println("BigInteger");
	}
}

import java.util.Scanner;
public class Main {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        try {
            long n = sc.nextLong();
            if (n <= 127)
                System.out.println("byte");
            else if (n <= 32767)
                System.out.println("short");
            else if (n <= 2147483647)
                System.out.println("int");
            else
                System.out.println("long");
        }
        catch (Exception ex){
            System.out.println("BigInteger ");
        }

    }
}

import java.math.BigInteger;
import java.util.*;
public class Petya_and_java
{
    public static void main(String[] args)
    {
        Scanner in = new Scanner(System.in);
        String data = in.nextLine();
        BigInteger integ = new BigInteger(data);
        BigInteger one = new BigInteger("127");
        BigInteger one_ = new BigInteger("-128");
        BigInteger two = new BigInteger("32767");
        BigInteger two_ = new BigInteger("-32768");
        BigInteger three = new BigInteger("2147483647");
        BigInteger three_ = new BigInteger("-2147483648");
        BigInteger four = new BigInteger("9223372036854775807");
        BigInteger four_ = new BigInteger("-9223372036854775808");
        boolean flag = true;
        if((integ.compareTo(one)==0||integ.compareTo(one)==-1)&&(integ.compareTo(one_)==0||integ.compareTo(one_)==1)&&flag == true)
        {
            System.out.print("byte");
            flag =false;
        }
        if((integ.compareTo(two)==0||integ.compareTo(two)==-1)&&(integ.compareTo(two_)==0||integ.compareTo(two_)==1)&&flag==true)
        {
            System.out.print("short");
            flag =false;
        }
        if((integ.compareTo(three)==0||integ.compareTo(three)==-1)&&(integ.compareTo(three_)==0||integ.compareTo(three_)==1)&&flag == true)
        {
            System.out.print("int");
            flag =false;
        }
        if((integ.compareTo(four)==0||integ.compareTo(four)==-1)&&(integ.compareTo(four_)==0||integ.compareTo(four_)==1)&&flag == true)
        {
            System.out.print("long");flag =false;
        }
        if(integ.compareTo(four)==1&&flag == true)
        {
            System.out.print("BigInteger");
        }
    }

}

import java.io.*;
import java.math.*;

public class Main {
    static String[][] arr =
        new String[][] {{"byte", "-128", "127"}, {"short", "-32768", "32767"}, {"int", "-2147483648", "2147483647"},
            {"long", "-9223372036854775808", "9223372036854775807"}, {"BigInteger", "-1"}};
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

    public static void main(String[] args) throws IOException {
        //        br = new BufferedReader(new InputStreamReader(new FileInputStream("/Users/huangweixuan/testdata.txt")));
        BigInteger bi = new BigInteger(br.readLine()), bi1, bi2;
        for (int i = 0; i < 4; ++i) {
            bi1 = new BigInteger(arr[i][1]);
            bi2 = new BigInteger(arr[i][2]);
            if (bi.min(bi1).equals(bi) && !bi.equals(bi1) || bi.max(bi2).equals(bi) && !bi.equals(bi2)) {
                continue;
            }
            bw.write(arr[i][0]);
            bw.close();
            return;
        }
        bw.write(arr[4][0]);
        bw.close();
    }
}

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

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String line = br.readLine();

        if (line.length() > 20) {
            System.out.println("BigInteger");
        } else {
            BigInteger b = new BigInteger(line);
            BigInteger byteMin = new BigInteger("-128");
            BigInteger byteMax = new BigInteger("127");
            BigInteger shortMin = new BigInteger("-32768");
            BigInteger shortMax = new BigInteger("32767");
            BigInteger intMin = new BigInteger("-2147483648");
            BigInteger intMax = new BigInteger("2147483647");
            BigInteger longMin = new BigInteger("-9223372036854775808");
            BigInteger longMax = new BigInteger("9223372036854775807");

            if (b.compareTo(byteMin) >= 0 && b.compareTo(byteMax) <= 0) {
                System.out.println("byte");
            }
            else if (b.compareTo(shortMin) >= 0 && b.compareTo(shortMax) <= 0) {
                System.out.println("short");
            }
            else if (b.compareTo(intMin) >= 0 && b.compareTo(intMax) <= 0) {
                System.out.println("int");
            }
            else if (b.compareTo(longMin) >= 0 && b.compareTo(longMax) <= 0) {
                System.out.println("long");
            }
            else {
                System.out.println("BigInteger");
            }

        }
        br.close();
    }
}

import java.math.BigInteger;
import java.util.Scanner;

import static java.lang.System.out;
import static java.math.BigInteger.valueOf;

/**
 * @author artyom
 */
public class PetyaAndJava {
    public static void main(String args[]) {
        Scanner sc = new Scanner(System.in);
        BigInteger n = sc.nextBigInteger();
        if (n.compareTo(valueOf(Long.MAX_VALUE)) > 0) {
            out.println("BigInteger");
        } else if (n.compareTo(valueOf(Integer.MAX_VALUE)) > 0) {
            out.println("long");
        } else if (n.compareTo(valueOf(Short.MAX_VALUE)) > 0) {
            out.println("int");
        } else if (n.compareTo(valueOf(Byte.MAX_VALUE)) > 0) {
            out.println("short");
        } else {
            out.println("byte");
        }
    }
}

import java.math.BigInteger;
import java.util.Scanner;

public class A_61 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		BigInteger s = sc.nextBigInteger();
		if (s.compareTo(BigInteger.valueOf(Byte.MAX_VALUE)) <= 0) {
			System.out.println("byte");
		} else if (s.compareTo(BigInteger.valueOf(Short.MAX_VALUE)) <= 0) {
			System.out.println("short");
		} else if (s.compareTo(BigInteger.valueOf(Integer.MAX_VALUE)) <= 0) {
			System.out.println("int");
		} else if (s.compareTo(BigInteger.valueOf(Long.MAX_VALUE)) <= 0) {
			System.out.println("long");
		} else
			System.out.println("BigInteger");
	}
}

             // package main;
import java.io.*;
import java.math.*;
import java.util.*;
import java.awt.*;
/**
*
* @author Togrul Gasimov (ttogrul30@gmail.com)
*
*/

public class Main {
public static void main(String[] args) /*throws FileNotFoundException*/ {
   InputStream inputStream = System.in;
   OutputStream outputStream = System.out;
   FastScanner in = new FastScanner(inputStream);
   FastPrinter out = new FastPrinter(outputStream);
   TaskB solver = new TaskB();
   solver.solve(1, in, out);
   out.close();
}
}

class TaskB{
public void solve(int testNumber, FastScanner scan, FastPrinter out) /*throws FileNotFoundException*/ {
   //Scanner sscan = new Scanner(new File("input.txt"));
   //PrintStream oout = new PrintStream(new File("output.txt"));
    BigInteger a = scan.nextBigInteger();
    if(a.compareTo(BigInteger.valueOf(-128)) >= 0 && a.compareTo(BigInteger.valueOf(127)) <= 0){
        out.println("byte");
    }else if(a.compareTo(BigInteger.valueOf(-32768)) >= 0 && a.compareTo(BigInteger.valueOf(32767)) <= 0){
        out.println("short");
    }else if(a.compareTo(BigInteger.valueOf(-2147483648)) >= 0 && a.compareTo(BigInteger.valueOf(2147483647)) <= 0){
        out.println("int");
    }else if(a.compareTo(new BigInteger("-9223372036854775808")) >= 0 && a.compareTo(new BigInteger("9223372036854775807")) <= 0){
        out.println("long");
    }else {
        out.println("BigInteger");
    }
   //sscan.close();
   //oout.close();
}
}

class FastScanner extends BufferedReader {
public FastScanner(InputStream is) {
   super(new InputStreamReader(is));
}

public int read() {
   try{
       int ret = super.read();
       return ret;
   }catch(Exception e){
       throw new InputMismatchException();
   }
}

public String next() {
   StringBuilder sb = new StringBuilder();
   int c = read();
   while (isWhiteSpace(c)) {
       c = read();
   }
   if (c < 0) {
       return null;
   }
   while (c >= 0 && !isWhiteSpace(c)) {
       sb.appendCodePoint(c);
       c = read();
   }
   return sb.toString();
}

static boolean isWhiteSpace(int c) {
   return c >= 0 && c <= 32;
}

public int nextInt() {
   int c = read();
   while (isWhiteSpace(c)) {
       c = read();
   }
   int sgn = 1;
   if (c == '-') {
       sgn = -1;
       c = read();
   }
   int ret = 0;
   while (c >= 0 && !isWhiteSpace(c)) {
       if (c < '0' || c > '9') {
           throw new NumberFormatException("digit expected " + (char) c
                   + " found");
       }
       ret = ret * 10 + c - '0';
       c = read();
   }
   return ret * sgn;
}

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

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

public BigInteger nextBigInteger() {
   return new BigInteger(next());
}

public BigDecimal nextBigDecimal(){
   return new BigDecimal(next());
}

public String readLine(){
   try{
       return super.readLine();
   }catch(IOException e){
       return null;
   }
}
}

class FastPrinter extends PrintWriter {

public FastPrinter(OutputStream out) {
   super(out);
}
public FastPrinter(Writer out) {
   super(out);
}
}

import java.math.BigInteger;
import java.util.Scanner;
public class Main {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        BigInteger bd;
        Scanner sc = new Scanner(System.in);
        bd = sc.nextBigInteger();
        if(bd.compareTo(new BigInteger("127"))<= 0 && bd.compareTo(new BigInteger("-128"))>= 0)
        {
            System.out.println("byte");

        }
        else if(bd.compareTo(new BigInteger("32767"))<= 0 && bd.compareTo(new BigInteger("-32768"))>= 0)
        {
            System.out.println("short");
        }
        else if(bd.compareTo(new BigInteger("2147483647"))<= 0 && bd.compareTo(new BigInteger("-2147483648"))>= 0)
        {
            System.out.println("int");
        }
        else if(bd.compareTo(new BigInteger("9223372036854775807"))<= 0 && bd.compareTo(new BigInteger("-9223372036854775808"))>= 0)
        {
            System.out.println("long");
        }
        else
        {
            System.out.println("BigInteger");
        }

    }

}

import java.util.Scanner;
public class MainCode
{
    public static void main (String[] args)
    {
        Scanner Input = new Scanner(System.in);
        String Str = Input.next();
        try{
             Byte.parseByte(Str);
             System.out.println("byte");
             return;
           }
        catch( NumberFormatException NFE)
        {
            try{
                Short.parseShort(Str);
                System.out.println("short");
                return;
               }
               catch( NumberFormatException NFE1)
               {
                 try{
                     Integer.parseInt(Str);
                     System.out.println("int");
                     return;
                    }
                 catch( NumberFormatException NFE2)
                   {
                     try{
                         Long.parseLong(Str);
                         System.out.println("long");
                         return;
                        }
                       catch( NumberFormatException NFE3)
                       {
                         System.out.println("BigInteger");
                       }
                   }
               }
        }

    }
}

import java.util.Scanner;

public class PetyaAndJava {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String w = in.nextLine();
        try {
            byte z = Byte.parseByte(w);
            System.out.println("byte");
        } catch (Exception e) {
            try {
                short x = Short.parseShort(w);
                System.out.println("short");
            } catch (Exception e2) {
                try {
                    int c = Integer.parseInt(w);
                    System.out.println("int");
                } catch (Exception e3) {
                    try {
                        long v = Long.parseLong(w);
                        System.out.println("long");
                    } catch (Exception e4) {
                        System.out.println("BigInteger");
                    }
                }
            }
        }

    }

}

import java.math.BigInteger;
import java.util.Scanner;

public class A_66_Petya_and_Java {
	public static void main(String[] args){
		Scanner input=new Scanner(System.in);
		String num=input.next();
		BigInteger number=new BigInteger(num);
		if(number.compareTo(BigInteger.valueOf(-128))==1&&number.compareTo(BigInteger.valueOf(127))==-1){
			System.out.println("byte");
		}
		else if(number.compareTo(BigInteger.valueOf(-128))==0){
			System.out.println("byte");
		}
		else if(number.compareTo(BigInteger.valueOf(127))==0){
			System.out.println("byte");
		}
		else if(number.compareTo(BigInteger.valueOf(-32768))==1&&number.compareTo(BigInteger.valueOf(32767))==-1){
			System.out.println("short");
		}
		else if(number.compareTo(BigInteger.valueOf(-32768))==0){
			System.out.println("short");
		}
		else if(number.compareTo(BigInteger.valueOf(32767))==0){
			System.out.println("short");
		}
		else if(number.compareTo(BigInteger.valueOf(-2147483648))==1&&number.compareTo(BigInteger.valueOf(2147483647))==-1){
			System.out.println("int");
		}
		else if(number.compareTo(BigInteger.valueOf(-2147483648))==0){
			System.out.println("int");
		}
		else if(number.compareTo(BigInteger.valueOf(2147483647))==0){
			System.out.println("int");
		}
		else if(number.compareTo(new BigInteger("-9223372036854775808"))==1&&number.compareTo(new BigInteger("9223372036854775807"))==-1){
			System.out.println("long");
		}
		else if(number.compareTo(new BigInteger("-9223372036854775808"))==0){
			System.out.println("long");
		}
		else if(number.compareTo(new BigInteger("9223372036854775807"))==0){
			System.out.println("long");
		}
		else{
			System.out.println("BigInteger");
		}
	}
}

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.Reader;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {
    public static String fileIn = "Input.txt";
    public static String fileOut = "Output.txt";
    public static final String noNextString = "This is the end";
    public static final String noNext = "-1";

    public static void main(String[] args) throws Exception {
        PrintWriter jout = new PrintWriter(System.out);
        Scanner jin = new Scanner(new InputStreamReader(System.in));
        BigInteger n = jin.nextBigInteger();
        if (n.compareTo(new BigInteger(((Long)((1l << 7) - 1)).toString())) <= 0)
        	System.out.println("byte");
        else if (n.compareTo(new BigInteger(((Long)((1l << 15) - 1)).toString())) <= 0)
        	 System.out.println("short");
        else if (n.compareTo(new BigInteger(((Long)((1l << 31) - 1)).toString())) <= 0)
        	 System.out.println("int");
        else if (n.compareTo(new BigInteger(((Long)((1l << 63) - 1)).toString())) <= 0) {
        	 System.out.println("long");
        }
        else
        	 System.out.println("BigInteger");

         jout.close();
    }
}

public class TipeData43
{
    public static void main(String[]args)
    {
        java.util.Scanner reader = new java.util.Scanner(System.in);
        String baca = reader.next();
        long result = 0;
        try
        {
            result = Long.parseLong(baca);
            if(result<Integer.MIN_VALUE||result>Integer.MAX_VALUE)
            {
                System.out.println("long");
            }
            else if(result<Short.MIN_VALUE||result>Short.MAX_VALUE)
            {
                System.out.println("int");
            }
            else if(result<Byte.MIN_VALUE||result>Byte.MAX_VALUE)
            {
                System.out.println("short");
            }
            else
            {
                System.out.println("byte");
            }
        }
        catch(NumberFormatException e)
        {
            System.out.println("BigInteger");
        }
    }
}

import java.util.Scanner;
import java.math.BigInteger;
public class CF66A {
static Scanner sc =new Scanner(System.in);
	public static void main(String[] args) {
		BigInteger num;
		num = sc.nextBigInteger();
		if(num.compareTo(new BigInteger("-9223372036854775808"))<0 )
		{
			System.out.println("BigInteger");
		}
		else if(num.compareTo(new BigInteger("-2147483648"))<0)
		{
			System.out.println("long");
		}
		else if(num.compareTo(new BigInteger("-32768"))<0)
		{
			System.out.println("int");
		}
		else if(num.compareTo(new BigInteger("-128"))<0)
		{
			System.out.println("short");
		}
		else if(num.compareTo(new BigInteger("127"))<=0)
		{
			System.out.println("byte");
		}
		else if(num.compareTo(new BigInteger("32767"))<=0)
		{
			System.out.println("short");
		}
		else if(num.compareTo(new BigInteger("2147483647"))<=0)
		{
			System.out.println("int");
		}
		else if(num.compareTo(new BigInteger("9223372036854775807"))<=0)
		{
			System.out.println("long");
		}
		else
		{
			System.out.println("BigInteger");
		}

	}

}

import java.util.Scanner;

public class Petya_and_Java
{
    public static void main(String[] args)
    {
        long v;
        Scanner in = new Scanner(System.in);
        try
        {
        v=in.nextLong();
        while(true)
        {
           if(v>=-128&&v<=127)
           {
               System.out.println("byte");
               break;
           }
             if(v>=-32768&&v<=32767)
             {
                 System.out.println("short");
               break;

             }
             if(v>=-2147483648&&v<=2147483647)
             {
                 System.out.println("int");
               break;
             }
             else
             {
                 System.out.println("long");
               break;
             }

        }
        }
        catch(Exception e)
        {
            System.out.println("BigInteger");
        }

    }

}

import java.math.BigInteger;
import java.util.Scanner;

public class Code {

    public static String toBinary(BigInteger x){
        String s="";
        BigInteger d = BigInteger.ONE;
        d = d.add(BigInteger.ONE);
        while (!x.equals(BigInteger.ONE)){
            s = (x.mod(d)).toString() + s;
            x = x.divide(d);
        }
        return 1+s;
    }

    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        BigInteger x = input.nextBigInteger();
        String s = toBinary(x);
        int n = s.length();

        if (n+1 > 8*8)
            System.out.print("BigInteger");
        else if (n+1 > 4*8)
            System.out.print("long");
        else if (n+1 > 2*8)
            System.out.print("int");
        else if (n+1 > 1*8)
            System.out.print("short");
        else
            System.out.print("byte");
    }
}

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
//package codeforces;

/**
 *
 * @author xerxes
 */
import java.lang.*;
import java.io.*;
import java.math.*;
import java.text.*;
import java.util.*;

public class Main {

    String ss;
    BufferedReader bf;
    char[][] grid;

    public static void main(String[] args) throws IOException {
        Main ob = new Main();
        ob.doit();
        System.exit(0);
    }

    public void doit() throws IOException {
        bf = new BufferedReader(new InputStreamReader(System.in));
        ss = bf.readLine().trim();

        BigInteger bg = new BigInteger("0");

        for (int i = 0; i < ss.length(); ++i) {
            bg = bg.multiply(BigInteger.valueOf((long) 10));
            long v = (long) ss.charAt(i) - '0';
            bg = bg.add(BigInteger.valueOf(v));
        }
        //System.out.println(bg);
        BigInteger[] v = new BigInteger[8];
        v[0] = new BigInteger("-129");
        v[1] = new BigInteger("128");

        v[2] = new BigInteger("-32769");
        v[3] = new BigInteger("32768");

        v[4] = new BigInteger("-2147483649");
        v[5] = new BigInteger("2147483648");

        v[6] = new BigInteger("-9223372036854775809");
        v[7] = new BigInteger("9223372036854775808");

        if (bg.compareTo(v[0]) == 1 && bg.compareTo(v[1]) == -1) {
            System.out.println("byte");
        } else if (bg.compareTo(v[2]) == 1 && bg.compareTo(v[3]) == -1) {
            System.out.println("short");
        } else if (bg.compareTo(v[4]) == 1 && bg.compareTo(v[5]) == -1) {
            System.out.println("int");
        } else if (bg.compareTo(v[6]) == 1 && bg.compareTo(v[7]) == -1) {
            System.out.println("long");
        } else {
            System.out.println("BigInteger");
        }

        return;
    }
}

import java.util.*;
public class  Main {
   public static void main(String[] args)
   {
       Scanner in = new Scanner (System.in);
       String s = in.next();
       try
       {
       long f = Long.parseLong(s);
       if (f>=-128&&f<=127) System.out.println("byte");
       else if (f>=-32768&&f<=32767) System.out.println("short");
       else if (f>=-2147483648&&f<=2147483647) System.out.println("int");
       else System.out.println("long");
       }
       catch (Exception e)
       {
           System.out.println("BigInteger");
       }
   }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class CF {

	static InputReader in = new InputReader(System.in);

	public static void main(String[] args) throws Exception {

		String heading = in.readLine();

		try {
			Byte.parseByte(heading);
			System.out.println("byte");
		} catch (NumberFormatException e) {
			try {
				Short.parseShort(heading);
				System.out.println("short");
			} catch (NumberFormatException f) {
				try {
					Integer.parseInt(heading);
					System.out.println("int");
				} catch (NumberFormatException g) {
					try {
						Long.parseLong(heading);
						System.out.println("long");
					} catch (NumberFormatException h) {
						System.out.println("BigInteger");
					}
				}
			}
		}
	}
}

class InputReader {
	private BufferedReader reader;
	private 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 String readLine() {
		try {
			return reader.readLine();
		} catch (IOException e) {
			throw new RuntimeException(e);
		}
	}

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

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

	public char nextChar() {
		return next().charAt(0);
	}

}

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

public class A {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        BigInteger i = s.nextBigInteger();
        String r = "BigInteger";
        if (i.compareTo(valueOf(Byte.MAX_VALUE)) <= 0) {
            r = "byte";
        } else if (i.compareTo(valueOf(Short.MAX_VALUE)) <= 0) {
            r = "short";
        } else if (i.compareTo(valueOf(Integer.MAX_VALUE)) <= 0) {
            r = "int";
        } else if (i.compareTo(valueOf(Long.MAX_VALUE)) <= 0) {
            r = "long";
        }
        System.out.println(r);
    }
}

import java.math.BigInteger;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String s1 = in.nextLine();
        BigInteger q = new BigInteger(s1);
        if ((q.compareTo(new BigInteger(String.valueOf(Byte.MAX_VALUE))) <=0) && ((q.compareTo(new BigInteger(String.valueOf(Byte.MIN_VALUE)))>=0))) {
            System.out.println("byte");
        } else if ((q.compareTo(new BigInteger(String.valueOf(Short.MAX_VALUE))) <=0) && ((q.compareTo(new BigInteger(String.valueOf(Short.MIN_VALUE)))>=0))) {
            System.out.println("short");
        } else if ((q.compareTo(new BigInteger(String.valueOf(Integer.MAX_VALUE))) <=0) && ((q.compareTo(new BigInteger(String.valueOf(Integer.MIN_VALUE)))>=0))) {
            System.out.println("int");
        } else if ((q.compareTo(new BigInteger(String.valueOf(Long.MAX_VALUE))) <=0) && ((q.compareTo(new BigInteger(String.valueOf(Long.MIN_VALUE)))>=0))) {
            System.out.println("long");
        } else {
            System.out.println("BigInteger");
        }

    }
}

/* package whatever; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;
import java.io.Console;
import java.math.BigInteger;
import java.io.InputStreamReader;

/* Name of the class has to be "Main" only if the class is public. */
public class Main
{
    public static void main (String[] args)  throws IOException
    {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String input = br.readLine();
        BigInteger x = new BigInteger(input);
        BigInteger longg = new BigInteger("9223372036854775807");
        BigInteger intt = new BigInteger("2147483647");

        if (x.equals(x.min(BigInteger.valueOf(127))))
               System.out.println("byte");
        else if (x.equals(x.min(BigInteger.valueOf(32767))))
               System.out.println("short");
        else if (x.equals(x.min(intt)))
               System.out.println("int");
        else if (x.equals(x.min(longg)))
               System.out.println("long");
        else
            System.out.println("BigInteger");

    }
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Locale;
public class array2 {
    public static void main(String[] args) {
InputStreamReader in=new InputStreamReader(System.in);
BufferedReader con=new BufferedReader(in);
try {
String s1=con.readLine();String s="9223372036854775807";
if(Long.parseLong(s1)<=127)
    System.out.println("byte");
else if(Long.parseLong(s1)<=32767)
    System.out.println("short");
else if(Long.parseLong(s1)<=2147483647)
    System.out.println("int");
else if(Long.parseLong(s1)<=Long.parseLong(s))
    System.out.println("long");

} catch (Exception e) {
    System.out.println("BigInteger");
}
    }
}

import java.math.BigInteger;
import java.util.Scanner;

public class PetyaandJava66A {
	public static void main(String [] args){
		Scanner entrada = new Scanner(System.in);
		String s=entrada.next();
		System.out.println(valor(s));
	}

	public static String valor(String s){
		try{
			byte nB = Byte.valueOf(s);
			return "byte";
		}catch(Exception e){
		}
		try{
			short nS = Short.valueOf(s);
			return "short";
		}catch(Exception e){
		}
		try{
			int nI = Integer.valueOf(s);
			return "int";
		}catch(Exception e){
		}
		try{
			long nL = Long.valueOf(s);
			return "long";
		}catch(Exception e){
		}
		return "BigInteger";
	}
}

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Scanner;

public class Task066A {

	public static void main(String... args) throws NumberFormatException,
			IOException {
		Solution.main(System.in, System.out);
	}

	static class Solution {

		public static void main(InputStream is, OutputStream os)
				throws IOException {
			PrintWriter pw = new PrintWriter(os);
			Scanner s = new Scanner(is);

			String input = s.nextLine();

			try {
				Byte.parseByte(input);
				pw.println("byte");
			} catch (NumberFormatException e) {
				try {
					Short.parseShort(input);
					pw.println("short");
				} catch (NumberFormatException e2) {
					try {
						Integer.parseInt(input);
						pw.println("int");
					} catch (NumberFormatException e3) {
						try {
							Long.parseLong(input);
							pw.println("long");
						} catch (NumberFormatException e4) {
							pw.println("BigInteger");
						}
					}
				}
			}

			pw.flush();
			s.close();
		}
	}

}

import java.util.Scanner;
import java.math.BigInteger;

public class Main {

    public static void main(String[] args) {
        BigInteger x, y, z, a, b;
        Scanner k = new Scanner(System.in);
        x = k.nextBigInteger();
        y = new BigInteger("127");
        z = new BigInteger("32767");
        a = new BigInteger("2147483647");
        b = new BigInteger("9223372036854775807");
        if (x.compareTo(y) == -1 || x.compareTo(y) == 0)
            System.out.println("byte");
        else if (x.compareTo(z) == -1 || x.compareTo(z) == 0)
            System.out.println("short");
        else if (x.compareTo(a) == -1 || x.compareTo(a) == 0)
            System.out.println("int");
        else if (x.compareTo(b) == -1 || x.compareTo(b) == 0)
            System.out.println("long");
        else
            System.out.println("BigInteger");
    }
}

import java.io.InputStreamReader;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.math.BigInteger;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Bolat Kazybayev
 */
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) {
        String n = in.next();
        int length = n.length();
        if (length <= 3) {
            if (Short.parseShort(n) >= Byte.MIN_VALUE && Short.parseShort(n) <= Byte.MAX_VALUE)
                out.println("byte");
            else
                out.println("short");
        } else if (length <= 5) {
            if (Integer.parseInt(n) >= Short.MIN_VALUE && Integer.parseInt(n) <= Short.MAX_VALUE)
                out.println("short");
            else
                out.println("int");
        } else if (length <= 10) {
            if (Long.parseLong(n) >= Integer.MIN_VALUE  && Long.parseLong(n) <= Integer.MAX_VALUE)
                out.println("int");
            else
                out.println("long");
        } else if (length <= 19) {
            BigInteger min = new BigInteger(n);
            BigInteger minLong = new BigInteger("-9223372036854775808");
            BigInteger maxLong = new BigInteger("9223372036854775807");
            if (min.compareTo(minLong) >= 1 && min.compareTo(maxLong) <= 0)
                out.println("long");
            else
                out.println("BigInteger");
        } else
            out.println("BigInteger");
	}
}

class InputReader {
    private BufferedReader reader;
    private StringTokenizer tokenizer;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream));
        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();
    }

    }

import java.math.BigInteger;
import java.util.Scanner;

public class TypesJava {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		String s = scan.nextLine();
		if (s.length() <= 20) {
			BigInteger i = new BigInteger(s);

			BigInteger i1 = new BigInteger("-9223372036854775808");
			BigInteger i2 = new BigInteger("9223372036854775807");
			BigInteger i3 = new BigInteger("-2147483648");
			BigInteger i4 = new BigInteger("2147483647");
			BigInteger i5 = new BigInteger("-32768");
			BigInteger i6 = new BigInteger("32767");
			BigInteger i7 = new BigInteger("-128");
			BigInteger i8 = new BigInteger("127");
			if (i.compareTo(i7) >= 0 && i.compareTo(i8) <= 0)
				System.out.println("byte");
			else if (i.compareTo(i5) >= 0 && i.compareTo(i6) <= 0)
				System.out.println("short");
			else if (i.compareTo(i3) >= 0 && i.compareTo(i4) <= 0)
				System.out.println("int");
			else if (i.compareTo(i1) >= 0 && i.compareTo(i2) <= 0)
				System.out.println("long");
			else
				System.out.println("BigInteger");
		} else {
			System.out.println("BigInteger");
		}
	}

}

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

public class PetyaJava66A
{
    public static void main(String[] args)
    {
        // Set up scanner
        Scanner sc = new Scanner(System.in);
        // System.out.println("Enter the number (as a string)");
        String st = sc.next();

        BigInteger big = new BigInteger(st);
        BigInteger maxlong = new BigInteger("9223372036854775807");
        BigInteger minlong = new BigInteger("-9223372036854775808");
        if (big.compareTo(maxlong) > 0 || big.compareTo(minlong) < 0)
        {
            System.out.println("BigInteger");
            return;
        }
        long value = big.longValue();
        if (value >= -128 && value <= 127)
        {
            System.out.println("byte");
            return;
        }
        if (value >= -32768 && value <= 32767)
        {
            System.out.println("short");
            return;
        }
        if (value >= -2147483648 && value <= 2147483647)
        {
            System.out.println("int");
            return;
        }
        System.out.println("long");
    }
}

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.math.BigDecimal;
import java.math.BigInteger;
import java.util.Locale;
import java.util.StringTokenizer;

public class r61_a {
	static StringTokenizer st;
	static BufferedReader br;
	static PrintWriter pw;

	public static void main(String[] args) throws IOException {
		Locale.setDefault(Locale.US);
		br = new BufferedReader(new InputStreamReader(System.in));
		pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(
				System.out)));

		String n=next();
		if(n.length()<=9&&Integer.parseInt(n)>=-128&&Integer.parseInt(n)<=127)
			pw.print("byte");
		else
			if(n.length()<=9&&Integer.parseInt(n)>=-32768 &&Integer.parseInt(n)<= 32767)
				pw.print("short");
			else
				if(n.length()<=11&&Long.parseLong(n)>=-2147483648 &&Long.parseLong(n)<= 2147483647)
					pw.print("int");
				else
					if(new BigInteger(n).compareTo(BigInteger.ZERO.subtract(new BigInteger("9223372036854775808")))>=0&&
					new BigInteger(n).compareTo(new BigInteger("9223372036854775807"))<=0)
						pw.print("long");
						else
							pw.print("BigInteger");
		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(br.readLine());
		return st.nextToken();
	}
}

//package main;

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

public class Main {

  public static void main(String[] args) {
    Scanner cin = new Scanner(System.in);
    BigInteger d = new BigInteger(cin.nextLine());
    if((d.compareTo(new BigInteger("-129")) == 1) && (d.compareTo(new BigInteger("128")) == -1))
      System.out.print("byte");
    else if((d.compareTo(new BigInteger("-32769")) == 1) && (d.compareTo(new BigInteger("32768")) == -1))
      System.out.print("short");
    else if((d.compareTo(new BigInteger("-2147493649")) == 1) && (d.compareTo(new BigInteger("2147483648")) == -1))
      System.out.print("int");
    else if((d.compareTo(new BigInteger("-9223372036854775809")) == 1) && (d.compareTo(new BigInteger("9223372036854775808")) == -1))
      System.out.print("long");
    else
      System.out.print("BigInteger");
  }
}

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

//package a;

/**
 *
 * @author CDL
 */
import java.util.*;
import java.math.*;
import java.io.*;
public class Main {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
       Scanner  cin=new Scanner(System.in);
       while(cin.hasNext())
       {
         long s=Long.parseLong("9223372036854775807");
         BigInteger  aa,A,B,C,D,S;
         aa=cin.nextBigInteger();
         A=BigInteger.valueOf(s);
         B=BigInteger.valueOf(2147483647);
         C=BigInteger.valueOf(32767);
         D=BigInteger.valueOf(127);
         if(aa.compareTo(A)==1)
             System.out.println("BigInteger");
         else if (aa.compareTo(B) == 1)
        // else if(aa>B)
             System.out.println("long");
         else if (aa.compareTo(C) == 1)
        ///else if(aa>C)
             System.out.println("int");
         else if (aa.compareTo(D) == 1)
        ///else if(aa>D)
                 System.out.println("short");
         else     System.out.println("byte");

       }
    }

}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.math.BigInteger;

public class PetyaAndJava {

    void run() {
        try {
            BufferedReader bfd = new BufferedReader(new InputStreamReader(
                    System.in));
            String[] types = { "byte", "short", "int", "long", "BigInteger" };
            String s = bfd.readLine();
            BigInteger b = new BigInteger(s);
            if(b.compareTo(new BigInteger("127"))<=0 && b.compareTo(new BigInteger("-128"))>=0)
                System.out.println(types[0]);
            else if(b.compareTo(new BigInteger("32767"))<=0 && b.compareTo(new BigInteger("-32768"))>=0)
                System.out.println(types[1]);
            else if(b.compareTo(new BigInteger("2147483647"))<=0 && b.compareTo(new BigInteger("-2147483648"))>=0)
                System.out.println(types[2]);
            else if(b.compareTo(new BigInteger("9223372036854775807"))<=0 && b.compareTo(new BigInteger("-9223372036854775808"))>=0)
                System.out.println(types[3]);
            else
                System.out.println(types[4]);

        } catch (Exception e) {

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

}

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

import static java.lang.Integer.*;
import static java.lang.Math.*;
public class Code66A {

    public static void main(String[] args) throws Exception {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        BigInteger b = new BigInteger(in.readLine());
        if(b.compareTo(new BigInteger("-128")) >= 0 &&  b.compareTo(new BigInteger("127"))<=0){
            System.out.println("byte");
        }else if(b.compareTo(new BigInteger("-32768"))>=0 && b.compareTo(new BigInteger("32767"))<=0 ){
            System.out.println("short");
        }else if(b.compareTo(new BigInteger("-2147483648"))>=0 && b.compareTo(new BigInteger("2147483647"))<=0){
            System.out.println("int");
        }else if(b.compareTo(new BigInteger("-9223372036854775808"))>=0 && b.compareTo(new BigInteger("9223372036854775807"))<=0){
            System.out.println("long");
        }
        else System.out.println("BigInteger");
    }

}

import java.util.*;

public class Trying
{
    public static void main (String[] args)
    {
        Scanner enter = new Scanner(System.in);
        String n = enter.next(), poslong = "9223372036854775807",
        neglong = "9223372036854775808";
        if(n.length() <= 3 && Long.parseLong(n) <= 127
                && Long.parseLong(n) >= -128)
            System.out.println("byte");
        else if(n.length() <= 5 && Long.parseLong(n) <= 32767
                && Long.parseLong(n) >= -32768)
            System.out.println("short");
        else if(n.length() <= 10 && Long.parseLong(n) <= 2147483647
                && Long.parseLong(n) >= -2147483648)
            System.out.println("int");
        else if(n.length() < 19)
            System.out.println("long");
        else if(n.length() <= 20 && n.charAt(0) == '-')
        {
                for(int i = 1 ; i < n.length(); i++)
                {
                    if(n.charAt(i) > neglong.charAt(neglong.length()-(n.length())+i))
                    {
                        System.out.println("BigInteger");
                        System.exit(0);
                    }
                    else if(n.charAt(i) < neglong.charAt(neglong.length()-(n.length())+i))
                    {
                        System.out.println("long");
                        System.exit(0);
                    }
                }
                System.out.println("long");
        }
        else if(n.length() <= 19)
        {
                for(int i = 0 ; i < n.length(); i++)
                {
                    if(n.charAt(i) > poslong.charAt(neglong.length()-(n.length())+i))
                    {
                        System.out.println("BigInteger");
                        System.exit(0);
                    }
                    else if(n.charAt(i) < poslong.charAt(neglong.length()-(n.length())+i))
                    {
                        System.out.println("long");
                        System.exit(0);
                    }
                }
                System.out.println("long");
        }
        else
            System.out.println("BigInteger");
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;
public class one {
   public static void main(String[] args) throws IOException {
       BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
    BigInteger bd = new BigInteger(buf.readLine());
   if (bd.compareTo(BigInteger.valueOf(128)) == -1 && bd.compareTo(BigInteger.valueOf(-129)) == 1)
         System.out.println("byte");
      else
if (bd.compareTo(BigInteger.valueOf(32768)) == -1  && bd.compareTo(BigInteger.valueOf(-32768)) == 1)
              System.out.println("short");
          else if (bd.compareTo(BigInteger.valueOf(2147483648L)) == -1&& bd.compareTo(BigInteger.valueOf(-2147483649L)) == 1)
             System.out.println("int");
    else if (bd.compareTo(new BigInteger("9223372036854775808")) == -1&& bd.compareTo(new BigInteger("-9223372036854775809")) == 1)
              System.out.println("long");
         else System.out.println("BigInteger");
       }
}

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
      Scanner In=new Scanner(System.in);
        try{
            long n=In.nextLong();
            if(n<=127)System.out.println("byte");
            else if(n<=32767)System.out.println("short");
            else if(n<=2147483647)System.out.println("int");
            else System.out.println("long");
        }
        catch(Exception x){
            System.out.println("BigInteger");
        }

    }
}

import java.math.BigInteger;
import java.util.Scanner;

public class A66 {

	public static void main(String[] args) {

		Scanner s = new Scanner(System.in);
		BigInteger num = s.nextBigInteger();
		if (in("-128", "127", num)) {
			System.out.println("byte");
		} else if (in("-32768", "32767", num)) {
			System.out.println("short");
		} else if (in("-2147483648", "2147483647", num)) {
			System.out.println("int");
		} else if (in("-9223372036854775808", "9223372036854775807", num)) {
			System.out.println("long");
		} else {
			System.out.println("BigInteger");
		}

	}

	public static boolean in(String low, String high, BigInteger n) {

		BigInteger l = (new BigInteger(low)).subtract(new BigInteger("1"));
		BigInteger h = (new BigInteger(high)).add(new BigInteger("1"));
		return l.compareTo(n) == -1 && n.compareTo(h) == -1;

	}

}

import java.io.BufferedInputStream;
import java.math.BigInteger;
import java.util.Arrays;

public class C066A {

	public void solve() throws Exception {
		String s = nextWord();
		BigInteger i = new BigInteger(s);
		if (i.compareTo(BigInteger.valueOf(Byte.MAX_VALUE)) <= 0
				&& i.compareTo(BigInteger.valueOf(Byte.MIN_VALUE)) >= 0) {
			println("byte");
			return;
		}

		if (i.compareTo(BigInteger.valueOf(Short.MAX_VALUE)) <= 0
				&& i.compareTo(BigInteger.valueOf(Short.MIN_VALUE)) >= 0) {
			println("short");
			return;
		}

		if (i.compareTo(BigInteger.valueOf(Integer.MAX_VALUE)) <= 0
				&& i.compareTo(BigInteger.valueOf(Integer.MIN_VALUE)) >= 0) {
			println("int");
			return;
		}

		if (i.compareTo(BigInteger.valueOf(Long.MAX_VALUE)) <= 0
				&& i.compareTo(BigInteger.valueOf(Long.MIN_VALUE)) >= 0) {
			println("long");
			return;
		}
		println("BigInteger");
	}

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

	void debug(Object... os) {
		System.err.println(Arrays.deepToString(os));
	}

	void print(Object... os) {
		if (os != null && os.length > 0)
			System.out.print(os[0].toString());
		for (int i = 1; i < os.length; ++i)
			System.out.print(" " + os[i].toString());
	}

	void println(Object... os) {
		print(os);
		System.out.println();
	}

	BufferedInputStream bis = new BufferedInputStream(System.in);

	String nextWord() throws Exception {
		char c = (char) bis.read();
		while (c <= ' ')
			c = (char) bis.read();
		StringBuilder sb = new StringBuilder();
		while (c > ' ') {
			sb.append(c);
			c = (char) bis.read();
		}
		return new String(sb);
	}

	String nextLine() throws Exception {
		char c = (char) bis.read();
		while (c <= ' ')
			c = (char) bis.read();
		StringBuilder sb = new StringBuilder();
		while (c != '\n' && c != '\r') {
			sb.append(c);
			c = (char) bis.read();
		}
		return new String(sb);
	}

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

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

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

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

public class Main {
    public static void main(String[] args)throws Exception {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        String number = reader.readLine();
        String result = "BigInteger";
        try{
            Byte.parseByte(number);
            result = "byte";
        } catch (Exception e1){
            try{
                Short.parseShort(number);
                result = "short";
            } catch (Exception e2){
                try{
                    Integer.parseInt(number);
                    result = "int";
                } catch (Exception e3){
                    try{
                        Long.parseLong(number);
                        result = "long";
                    } catch (Exception e4){

                    }
                }
            }
        }
        System.out.println(result);

    }
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.IOException;
import java.math.BigInteger;
import java.util.StringTokenizer;

public class TaskA extends Thread {
    public TaskA() {
        this.input = new BufferedReader(new InputStreamReader(System.in));
        this.output = new PrintWriter(System.out);
        this.setPriority(Thread.MAX_PRIORITY);
    }

    private void solve() throws Throwable {
        BigInteger n = new BigInteger(nextToken());
        if (n.compareTo(BigInteger.valueOf(Byte.MIN_VALUE)) >= 0 && n.compareTo(BigInteger.valueOf(Byte.MAX_VALUE)) <= 0) {
            output.println("byte");
            return;
        }
        if (n.compareTo(BigInteger.valueOf(Short.MIN_VALUE)) >= 0 && n.compareTo(BigInteger.valueOf(Short.MAX_VALUE)) <= 0) {
            output.println("short");
            return;
        }
        if (n.compareTo(BigInteger.valueOf(Integer.MIN_VALUE)) >= 0 && n.compareTo(BigInteger.valueOf(Integer.MAX_VALUE)) <= 0) {
            output.println("int");
            return;
        }
        if (n.compareTo(BigInteger.valueOf(Long.MIN_VALUE)) >= 0 && n.compareTo(BigInteger.valueOf(Long.MAX_VALUE)) <= 0) {
            output.println("long");
            return;
        }
        output.println("BigInteger");

    }

    public void run() {
        try {
            solve();
        } catch (Throwable e) {
            System.err.println(e.getMessage());
            e.printStackTrace();
            System.exit(666);
        } finally {
            output.flush();
            output.close();
        }
    }

    public static void main(String[] args) {
        new TaskA().start();
    }

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

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

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

    private String nextToken() throws IOException {
        while (tokens == null || !tokens.hasMoreTokens()) {
            tokens = new StringTokenizer(input.readLine());
        }
        return tokens.nextToken();
    }

    private BufferedReader input;
    private PrintWriter output;
    private StringTokenizer tokens = null;
}

import java.io.*;
import java.math.BigInteger;
import java.util.*;
import static java.lang.Math.*;

public class A implements Runnable {

    final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;
    BufferedReader in;
    PrintWriter out;
    StringTokenizer tok = new StringTokenizer("");

    void init() throws IOException {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
    }

    String readString() throws IOException {
        while (!tok.hasMoreTokens()) {
            tok = new StringTokenizer(in.readLine());
        }
        return tok.nextToken();
    }

    int readInt() throws IOException {
        return Integer.parseInt(readString());
    }

    @Override
    public void run() {
        try {
            long t1 = System.currentTimeMillis();
            init();
            solve();
            out.close();
        } catch (Exception e) {
            e.printStackTrace(System.err);
            System.exit(-1);
        }
    }

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

    boolean in(long l, long r, BigInteger a) {
        BigInteger x = BigInteger.valueOf(l);
        BigInteger y = BigInteger.valueOf(r);
        return x.compareTo(a) <= 0 && a.compareTo(y) <= 0;
    }

    void solve() throws IOException {
        String s = readString();
        BigInteger n = new BigInteger( s );
        BigInteger a = BigInteger.valueOf( Byte.MAX_VALUE );
        BigInteger b = BigInteger.valueOf( Byte.MIN_VALUE );

        if ( ( n.compareTo( a ) == -1 || n.compareTo( a ) == 0 ) && ( n.compareTo( b )  == 1 || n.compareTo( b ) == 0 ) ) {
            out.println("byte");
            return;
        }

        a = BigInteger.valueOf( Short.MAX_VALUE );
        b = BigInteger.valueOf( Short.MIN_VALUE );

        if ( ( n.compareTo( a ) == -1 || n.compareTo( a ) == 0 ) && ( n.compareTo( b )  == 1 || n.compareTo( b ) == 0 ) ) {
            out.println( "short" );
            return;
        }

        a = BigInteger.valueOf( Integer.MAX_VALUE );
        b = BigInteger.valueOf( Integer.MIN_VALUE );

        if ( ( n.compareTo( a ) == -1 || n.compareTo( a ) == 0 ) && ( n.compareTo( b )  == 1 || n.compareTo( b ) == 0 ) ) {
            out.println( "int" );
            return;
        }

        a = BigInteger.valueOf( Long.MAX_VALUE );
        b = BigInteger.valueOf( Long.MIN_VALUE );

        if ( ( n.compareTo( a ) == -1 || n.compareTo( a ) == 0 ) && ( n.compareTo( b )  == 1 || n.compareTo( b ) == 0 ) ) {
            out.println( "long" );
            return;
        }

        out.println( "BigInteger" );

    }

}

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

public class Main {

	/**
	 * @param args
	 * @throws FileNotFoundException
	 */
	public static void main(String[] args) throws FileNotFoundException {
		Scanner in = new Scanner(System.in);
		PrintStream out = System.out;

		BigInteger byte1 = new BigInteger("-128");
		BigInteger byte2 = new BigInteger("127");

		BigInteger short1 = new BigInteger("-32768");
		BigInteger short2 = new BigInteger("32767");

		BigInteger int1 = new BigInteger("-2147483648");
		BigInteger int2 = new BigInteger("2147483647");

		BigInteger long1 = new BigInteger("-9223372036854775808");
		BigInteger long2 = new BigInteger("9223372036854775807");

		BigInteger a = in.nextBigInteger();

		if( a.compareTo(byte1) >=0 && ( a.compareTo(byte2) <=0 ) )
			out.print("byte");
		else if( a.compareTo(short1) >=0 && ( a.compareTo(short2) <=0  ) )
			out.print("short");
		else if( a.compareTo(int1) >=0 && ( a.compareTo(int2) <=0  ) )
			out.print("int");
		else if( a.compareTo(long1) >=0 && ( a.compareTo(long2) <=0  ) )
			out.print("long");
		else out.print("BigInteger");

		in.close();
		out.close();
	}

}

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Scanner;

public class main {

    public static void main (String args[]) {

        Scanner in = new Scanner(System.in);

        String i = in.nextLine();
        try{
            if(Byte.valueOf(i)>= -128 && Byte.valueOf(i)<=127)
                System.out.println("byte");
            return;
        }
        catch(NumberFormatException e){}
        try{
         if (Short.valueOf(i)>= -32768  && Short.valueOf(i)<=32767)
            System.out.println("short");
         return;
        }
        catch(NumberFormatException e){}
        try
        {
            if ((Integer.valueOf(i))>= -2147483648   && (Integer.valueOf(i))<=2147483647)
                System.out.println("int");
            return;
        }
        catch(NumberFormatException e){}
        try{
            if (Long.valueOf(i)>= -9223372036854775808L   && Long.valueOf(i)<=9223372036854775807L)
                System.out.println("long");
            return;
        }
        catch(NumberFormatException e){}

        System.out.println("BigInteger");
        return;
    }
}

import static java.lang.System.out;
import java.util.Scanner;

/**
 *
 * @author hussein
 */
public class Calculator {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
      //  new calcform().setVisible(true);
      Scanner input = new Scanner(System.in);
      try{
       long n = input.nextLong();
      if(n<=127)       out.println("byte");
      else if(n<=32767)  out.println("short");
      else if(n<=2147483647)  out.println("int");
      else                    out.println("long");}
      catch(Exception ex){
       out.println("BigInteger");}
    }

}

import java.util.Scanner;

public class Main {
    public static void main(String [] args){
        Scanner in=new Scanner(System.in);
       String str;
       str=in.next();
       if(str.charAt(0)!= '-' && (str.length() < 3 || str.length() == 3 && str.compareTo("127")  <= 0))
       {System.out.println("byte");}
       else  if(str.charAt(0)== '-' && (str.length() < 4 || str.length() == 4 && str.compareTo("-128")  <= 0))
       {System.out.println("byte");}
       else  if(str.charAt(0)!= '-' && (str.length() < 5 || str.length() == 5 && str.compareTo("32767")  <= 0))
       {System.out.println("short");}
       else  if(str.charAt(0)== '-' && (str.length() < 6 || str.length() == 6 && str.compareTo("-32768")  <= 0))
       {System.out.println("short");}
       else  if(str.charAt(0)!= '-' && (str.length() < 10 || str.length() == 10 && str.compareTo("2147483647")  <= 0))
       {System.out.println("int");}
       else  if(str.charAt(0)== '-' && (str.length() < 11 || str.length() == 11 && str.compareTo("-2147483648")  <= 0))
       {System.out.println("int");}
       else  if(str.charAt(0)!= '-' && (str.length() < 19 || str.length() == 19 && str.compareTo("9223372036854775807")  <= 0))
       {System.out.println("long");}
       else  if(str.charAt(0)== '-' && (str.length() < 20 || str.length() == 20 && str.compareTo("-9223372036854775808")  <= 0))
       {System.out.println("long");}
       else{
           System.out.println("BigInteger");
       }
    }
}

import java.awt.Point;
import java.io.*;
import java.util.*;
import java.math.*;
import static java.lang.Math.*;
import static java.lang.Integer.parseInt;
import static java.lang.Long.parseLong;
import static java.lang.Double.parseDouble;
import static java.lang.String.*;

public class Main {

    static StringBuilder a = new StringBuilder();

    public static void main(String[] args) throws IOException {
//        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
//(new FileReader("input.in"));
        StringBuilder out = new StringBuilder();
//        StringTokenizer tk;
//        tk = new StringTokenizer(in.readLine());
        //Scanner Reader = new Scanner(System.in);
        Reader.init(System.in);
        String x=Reader.next();
        try{Byte.parseByte(x);System.out.println("byte");System.exit(0);}catch(Exception e){}
        try{Short.parseShort(x);System.out.println("short");System.exit(0);}catch(Exception e){}
        try{parseInt(x);System.out.println("int");System.exit(0);}catch(Exception e){}
        try{parseLong(x);System.out.println("long");System.exit(0);}catch(Exception e){}
        System.out.println("BigInteger");
    }
}

class Reader {

    static StringTokenizer tokenizer;
    static BufferedReader reader;

    public static void init(InputStream input) throws UnsupportedEncodingException {
        reader = new BufferedReader(new InputStreamReader(input, "UTF-8"));
        tokenizer = new StringTokenizer("");
    }

    public static String next() throws IOException {
        while (!tokenizer.hasMoreTokens()) {
            tokenizer = new StringTokenizer(reader.readLine());
        }
        return tokenizer.nextToken();
    }

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

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

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

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

import java.util.Scanner;

public class word {
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);

        try
        {
            long num = scanner.nextLong();
            if (num>=-128 && num<=127) {
                System.out.println("byte");
            }
            else if (num>=-32768  && num<=32767){
                System.out.println("short");
            }
            else if (num>=-2147483648   && num<=2147483647){
                System.out.println("int");
            }
            else {
                System.out.println("long");
            }

        } catch (Exception e) {
            System.out.println("BigInteger");
        }

    }
}

import java.io.*;
import java.math.BigInteger;
import java.util.*;
import static java.lang.Math.*;

public class BetaRound61_A implements Runnable {

	final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;
	BufferedReader in;
	PrintWriter out;
	StringTokenizer tok = new StringTokenizer("");

	void init() throws IOException {
		if (ONLINE_JUDGE) {
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(System.out);
		} else {
			in = new BufferedReader(new FileReader("input.txt"));
			out = new PrintWriter("output.txt");
		}
	}

	String readString() throws IOException {
		while (!tok.hasMoreTokens()) {
			tok = new StringTokenizer(in.readLine());
		}
		return tok.nextToken();
	}

	int readInt() throws IOException {
		return Integer.parseInt(readString());
	}

	@Override
	public void run() {
		try {
			long t1 = System.currentTimeMillis();
			init();
			solve();
			out.close();
			long t2 = System.currentTimeMillis();
			System.err.println("Time = " + (t2 - t1));
		} catch (Exception e) {
			e.printStackTrace(System.err);
			System.exit(-1);
		}
	}

	public static void main(String[] args) {
		new Thread(new BetaRound61_A()).start();
	}

	boolean in(long l, long r, BigInteger a) {
		BigInteger x = BigInteger.valueOf(l);
		BigInteger y = BigInteger.valueOf(r);
		return x.compareTo(a) <= 0 && a.compareTo(y) <= 0;
	}

	void solve() throws IOException {
		BigInteger a = new BigInteger(readString());
		if (in(Byte.MIN_VALUE, Byte.MAX_VALUE, a)) {
			out.print("byte");
			return;
		}
		if (in(Short.MIN_VALUE, Short.MAX_VALUE, a)) {
			out.print("short");
			return;
		}
		if (in(Integer.MIN_VALUE, Integer.MAX_VALUE, a)) {
			out.print("int");
			return;
		}
		if (in(Long.MIN_VALUE, Long.MAX_VALUE, a)) {
			out.print("long");
			return;
		}
		out.print("BigInteger");
	}

}

import java.math.BigInteger;
import java.util.Scanner;

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
/**
 *
 * @author Jean Carlos
 */
public class PetyaAndJava {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        BigInteger n = sc.nextBigInteger();
        BigInteger n1 = BigInteger.valueOf(127);
        BigInteger n2 = BigInteger.valueOf(-128);
        BigInteger n3 = BigInteger.valueOf(32767);
        BigInteger n4 = BigInteger.valueOf(-32768);
        BigInteger n5 = BigInteger.valueOf(2147483647);
        BigInteger n6 = BigInteger.valueOf(-2147483648);
        BigInteger n7 = new BigInteger("9223372036854775807");
        BigInteger n8 = new BigInteger("-9223372036854775808");

        //System.out.println(n);
        if (n.compareTo(n1)<=0 && n.compareTo(n2)>=0) {
            System.out.println("byte");
        } else {
            if (n.compareTo(n3)<=0 && n.compareTo(n4)>=0) {
                System.out.println("short");
            } else {
                if (n.compareTo(n5)<=0 && n.compareTo(n6)>=0) {
                    System.out.println("int");
                } else {
                    if (n.compareTo(n7)<=0 && n.compareTo(n8)>=0) {
                        System.out.println("long");
                    } else {
                        System.out.println("BigInteger");
                    }
                }
            }
        }

    }
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.StreamTokenizer;
import java.math.BigInteger;

public class A {
    private static BufferedReader in;
    private static PrintWriter out;

//  private static int nextInt() throws Exception{
//      in.nextToken();
//      return (int)in.nval;
//  }
//
//  private static String nextString() throws Exception{
//      in.nextToken();
//      return in.sval;
//  }

    static{
        in = new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(System.out);
    }

    public static void main(String[] args)throws Exception{

        String s = in.readLine();

        BigInteger bi = new BigInteger(s);
        BigInteger a = new BigInteger("127");
        BigInteger a1 = new BigInteger("-128");
        BigInteger b = new BigInteger("32767");
        BigInteger b1 = new BigInteger("-32768");
        BigInteger c = new BigInteger("2147483647");
        BigInteger c1 = new BigInteger("-2147483648");
        BigInteger d = new BigInteger("9223372036854775807");
        BigInteger d1 = new BigInteger("-9223372036854775808");

        if(bi.compareTo(a) <= 0 && bi.compareTo(a1) >= 0) {
            out.println("byte");
            out.flush();
            return;
        }
        if(bi.compareTo(b) <= 0 && bi.compareTo(b1) >= 0) {
            out.println("short");
            out.flush();
            return;
        }
        if(bi.compareTo(c) <= 0 && bi.compareTo(c1) >= 0) {
            out.println("int");
            out.flush();
            return;
        }
        if(bi.compareTo(d) <= 0 && bi.compareTo(d1) >= 0) {
            out.println("long");
            out.flush();
            return;
        }

        out.println("BigInteger");
        out.flush();
    }
}

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Random;
import java.util.StringTokenizer;

public class solver implements Runnable {
    BufferedReader in;
    PrintWriter out;
    StringTokenizer tok = new StringTokenizer("");

    final boolean OJ = System.getProperty("ONLINE_JUDGE") != null;

    void init() throws FileNotFoundException {
        if (OJ) {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
        } else {
            in = new BufferedReader(new FileReader("input.txt"));
            out = new PrintWriter("output.txt");
        }
    }

    String readString() throws IOException {
        while (!tok.hasMoreTokens()) {
            try {
                tok = new StringTokenizer(in.readLine());
            } catch (Exception e) {
                return null;
            }
        }
        return tok.nextToken();
    }

    int readInt() throws IOException {
        return Integer.parseInt(readString());
    }

    long readLong() throws IOException {
        return Long.parseLong(readString());
    }

    double readDouble() throws IOException {
        return Double.parseDouble(readString());
    }

    public static void main(String[] args) {
        new Thread(null, new solver(), "", 128 * (1L << 20)).start();
    }

    public void run() {
        try {
            init();
            solve();
            out.close();
        } catch (IOException e) {
            System.err.println(e.getMessage());
            System.exit(-1);
        }
    }

    int gcd(int a, int b) {
        if (b == 0)
            return a;
        return gcd(b, a % b);
    }

    class City implements Comparable<City>{
        int dist;
        int count;
        City(int x,int y,int count){
            dist = x * x + y * y;
            this.count = count;
        }
        @Override
        public int compareTo(City other) {
            return dist - other.dist;
        }
    }

    boolean inSegment(BigInteger bi, long a, long b){
        if (bi.compareTo(BigInteger.valueOf(a)) < 0) return false;
        if (bi.compareTo(BigInteger.valueOf(b)) > 0) return false;
        return true;

    }

    void solve() throws IOException {
        String s = readString();
        if (s.length()>19){
            out.println("BigInteger");
            return;
        }
        BigInteger b = new BigInteger(s);
        if (inSegment(b, Byte.MIN_VALUE, Byte.MAX_VALUE)){
            out.println("byte");
            return;
        }
        if (inSegment(b, Short.MIN_VALUE, Short.MAX_VALUE)){
            out.println("short");
            return;
        }
        if (inSegment(b, Integer.MIN_VALUE, Integer.MAX_VALUE)){
            out.println("int");
            return;
        }
        if (inSegment(b, Long.MIN_VALUE, Long.MAX_VALUE)){
            out.println("long");
            return;
        }
        out.println("BigInteger");

    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.*;

public class Main {

    private boolean check(BigInteger b , BigInteger a) {
        return b.compareTo(a) <= 0;
    }

    private void solve() throws IOException {
        BigInteger n = new BigInteger(nextToken());
        if (check(n, new BigInteger("127"))) {
            out.println("byte");
        } else if (check(n, new BigInteger("32767"))) {
            out.println("short");
        } else if (check(n, new BigInteger("2147483647"))) {
            out.println("int");
        }  else if (check(n, new BigInteger("9223372036854775807"))) {
            out.println("long");
        }  else {
            out.println("BigInteger");
        }
    }

    public static void main(String[] args) {

        try {
            br = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
            new Main().solve();
            out.close();
        } catch (Throwable e) {
            e.printStackTrace();
            System.exit(239);
        }
    }
    static BufferedReader br;
    static StringTokenizer st;
    static PrintWriter out;

    static String nextToken() throws IOException {
        while (st == null || !st.hasMoreTokens()) {
            String line = br.readLine();
            if (line == null) {
                return null;
            }
            st = new StringTokenizer(line);
        }
        return st.nextToken();
    }

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

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

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

    static int[] nextIntArray(int n) throws IOException {
        int[] temp = new int[n];
        for (int x = 0; x < n; x++) {
            temp[x] = nextInt();
        }
        return temp;
    }

    static long[] nextLongArray(int n) throws IOException {
        long[] temp = new long[n];
        for (int x = 0; x < n; x++) {
            temp[x] = nextLong();
        }
        return temp;
    }

    static String[] nextArray(int n) throws IOException {
        String[] temp = new String[n];
        for (int x = 0; x < n; x++) {
            temp[x] = nextToken();
        }
        return temp;
    }

    static <T> void debug(T x) {
        System.out.println("debug x: " + x.toString());
    }

    static void debugInt(int[] x) {
        for (int a = 0; a < x.length; a++) {
            System.out.println("debug array no: " + a + " value: " + x[a]);
        }
    }

    static void debugArray(String[] x) {
        for (int a = 0; a < x.length; a++) {
            System.out.println("debug array no: " + a + " value: " + x[a]);
        }
    }
}

import java.util.Scanner;
/*
 * @author zezo
 * date : Feb 5, 2014
 */

public class PetyaandJava {

    public static void main(String[] args) throws Exception {
        Scanner scanner = new Scanner(System.in);
        String num = scanner.next();
        if ((num.length() > 10 && num.length() < 19)
                || (num.length() == 10 && num.charAt(0) == '3')
                || (num.length() == 10 && num.charAt(0) == '4')
                || (num.length() == 10 && num.charAt(0) == '5')
                || (num.length() == 10 && num.charAt(0) == '6')
                || (num.length() == 10 && num.charAt(0) == '7')
                || (num.length() == 10 && num.charAt(0) == '8')
                || (num.length() == 10 && num.charAt(0) == '9')
                || (num.length() == 10 && num.charAt(9) == '8')
                || (num.length() == 10 && num.charAt(9) == '9')
                || (num.length() == 19 && num.charAt(18) == '0')
                || (num.length() == 19 && num.charAt(18) == '1')
                || (num.length() == 19 && num.charAt(18) == '2')
                || (num.length() == 19 && num.charAt(18) == '3')
                || (num.length() == 19 && num.charAt(18) == '4')
                || (num.length() == 19 && num.charAt(18) == '5')
                || (num.length() == 19 && num.charAt(18) == '6')
                || (num.length() == 19 && num.charAt(18) == '7')) {
            System.out.println("long");
        } else if ((num.length() > 19)
                || (num.length() == 19 && num.charAt(18) == '8')
                || (num.length() == 19 && num.charAt(18) == '9')) {
            System.out.println("BigInteger");
        } else {
            int no = Integer.parseInt(num);
            if (no <= 127) {
                System.out.println("byte");
            } else if (no <= 32767) {
                System.out.println("short");
            } else if (no <= 2147483647) {
                System.out.println("int");
            }
        }

    }
}

import java.util.Scanner;

public class A {
	public static void main(String[] args) {
		Scanner nm = new Scanner(System.in);
		if (nm.hasNextByte()) {
			System.out.println("byte");
		}else{
			if (nm.hasNextShort()) {
				System.out.println("short");
			}else{
				if (nm.hasNextInt()) {
					System.out.println("int");
				}else{
					if (nm.hasNextLong()) {
						System.out.println("long");
					}else{
						System.out.println("BigInteger");
					}
				}
			}
		}

			}
}

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

public class Main
{
    public static void main(String[] args)
    {
        Scanner s = new Scanner(System.in);

        String t ,r;
        while(s.hasNext())
        {
            r= "BigInteger";
            BigInteger i;
            i = s.nextBigInteger();
            t=i.toString();
            int len=t.length();
            if(len<3)
                r = "byte";
            else if (len==3&&t.compareTo("127") <= 0) {
            r = "byte";}
            else if(len<5)
                r = "short";
            else if (len==5&&t.compareTo("32767") <= 0) {
            r = "short";}
            else if(len<10)
                r = "int";
            else if (len==10&&t.compareTo("2147483647") <= 0) {
            r = "int";}
            else if(len<19)
                r = "long";
            else if (len==19&&t.compareTo("9223372036854775807") <= 0) {
             r = "long";}
        System.out.println(r);
        }
        }
}

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.Stack;

import com.sun.jndi.url.iiopname.iiopnameURLContextFactory;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        if(scanner.hasNextByte()){
            System.out.println("byte");
        }else if(scanner.hasNextShort()){
            System.out.println("short");
        }else if(scanner.hasNextInt()){
            System.out.println("int");
        }else {
            if(scanner.hasNextLong()){
                System.out.println("long");
            }else{
                System.out.println("BigInteger");
            }
        }
    }
}

import java.util.*;

public class PetyaAndJava {
	public static void main(String[] args) {
		Scanner cin = new Scanner(System.in);
		if (cin.hasNextByte()) {
			System.out.println("byte");
		} else if (cin.hasNextShort()) {
			System.out.println("short");
		} else {
			if (cin.hasNextInt()) {
				System.out.println("int");
			} else {
				if (cin.hasNextLong()) {
					System.out.println("long");
				} else
					System.out.println("BigInteger");
			}
		}
	}
}

import java.util.Scanner;

public class Main {
    public static void main (String...args){
        Scanner input = new Scanner(System.in);
        String z;
        z = input.nextLine();
        if(z.length()<=10){
           if(Long.parseLong(z)>=0 && Long.parseLong(z)<=127){
              System.out.println("byte");
           }
           else if(Long.parseLong(z)>=128 && Long.parseLong(z)<=32767){
              System.out.println("short");
           }
           else if(Long.parseLong(z)>=32767 && Long.parseLong(z)<=2147483647){
              System.out.println("int");
           }
           else
               System.out.println("long");
        }

        else if((z.length()>=10 && z.length()<=19) && z.compareTo("9223372036854775807")<=0){
            System.out.println("long");
        }
        else{
            System.out.println("BigInteger");
        }
    }
}

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
      Scanner In=new Scanner(System.in);
        try{
            long n=In.nextLong();
            if(n<=127)System.out.println("byte");
            else if(n<=32767)System.out.println("short");
            else if(n<=2147483647)System.out.println("int");
            else System.out.println("long");
        }
        catch(Exception x){
            System.out.println("BigInteger");
        }

    }
}

import javax.swing.*;

import java.math.BigInteger;
import java.util.Scanner;;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        BigInteger val = sc.nextBigInteger();
        if (val.compareTo(BigInteger.valueOf(-128)) >= 0 && val.compareTo(BigInteger.valueOf(127)) <= 0) System.out.println("byte");
        else if (val.compareTo(BigInteger.valueOf(-32768)) >= 0 && val.compareTo(BigInteger.valueOf(32767)) <= 0) System.out.println("short");
        else if (val.compareTo(BigInteger.valueOf(-2147483648)) >= 0 && val.compareTo(BigInteger.valueOf(2147483647)) <= 0) System.out.println("int");
        else if (val.compareTo(BigInteger.valueOf(-9223372036854775808L)) >= 0 && val.compareTo(BigInteger.valueOf(9223372036854775807L)) <= 0) System.out.println("long");
        else System.out.println("BigInteger");
    }
}

import java.util.*;

public class Main {

    public static void main(String[] args)
    {
        Scanner sn = new Scanner( System.in);

        String s = sn.nextLine();

        if(s.length() < 19)
        {
            long n = Long.parseLong(s);
            if(n < 128)
                System.out.println("byte");
            else if(n <= 32767)
                System.out.println("short");
            else if(n <= 2147483647)
                System.out.println("int");
            else System.out.println("long");
        }
        if(s.length() == 19)
        {
            if(s.compareTo("9223372036854775807")<=0)
                System.out.println("long");
            else System.out.println("BigInteger");
        }
        if(s.length()>19)
            System.out.println("BigInteger");
    }
}

import java.util.Scanner;

public class Main
{
    public static void main(String[] args)
    {
	    Scanner stdin = new Scanner(System.in);
	    long n;
	    try
	    {
            n = stdin.nextLong();
	    }
        catch(Exception e)
        {
            System.out.println("BigInteger");
            return;
	    }
	    if(n >= -128 && n <= 127) System.out.println("byte");
	    else if(n >= -32768 && n <= 32767) System.out.println("short");
	    else if(n >= -2147483648 && n <= 2147483647) System.out.println("int");
	    else System.out.println("long");
    }
}

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

public class main{

    public static BigInteger gcdC(BigInteger a , BigInteger b){

        return b.equals(BigInteger.valueOf(0)) ? a : gcdC(b , a.remainder(b));

    }

    public static void main(String[] args) {
        MyScanner input =new MyScanner() ;
        out = new PrintWriter(new BufferedOutputStream(System.out));
        //out.println(gcd(input.nextInt() , input.nextInt())) ;
        Scanner input2 = new Scanner(System.in) ;

        BigInteger n  = input2.nextBigInteger() ;
        if(n.compareTo(BigInteger.valueOf(-128)) >=0 && n.compareTo(BigInteger.valueOf(127)) <=0 )
            out.println("byte") ;
        else if(n.compareTo(BigInteger.valueOf(-32768)) >=0 && n.compareTo(BigInteger.valueOf(32767)) <=0)
            out.println("short") ;
        else if(n.compareTo(BigInteger.valueOf(-2147483648)) >=0 && n.compareTo(BigInteger.valueOf(2147483647)) <=0)
            out.println("int") ;
        else if(n.compareTo(new BigInteger("-9223372036854775808")) >=0 && n.compareTo(new BigInteger("9223372036854775807")) <=0)
            out.println("long ") ;
        else
        out.println("BigInteger") ;

        out.close();
    }

    //-----------PrintWriter for faster output---------------------------------
    public static PrintWriter out;

    //-----------MyScanner class for faster input----------
    public static class MyScanner {
        BufferedReader br;
        StringTokenizer st;

        public MyScanner() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

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

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

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

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

        String nextLine(){
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
        BigInteger nextBigInteger(){ return new BigInteger(next()) ;}

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

import java.util.*;
public class Mohammad1  {
    public static void Mohammad_AboHasan(){
        Scanner fr = new Scanner(System.in);
        try{
            long n = fr.nextLong();
            if(n >= -128 && n <= 127)
                System.out.println("byte");
            else if(n >= -32768 && n <= 32767)
                System.out.println("short");
            else if(n >= -2147483648 && n <= 2147483647)
                System.out.println("int");
            else
                System.out.println("long");
            }
        catch(Exception e){
             System.out.println("BigInteger");
        }
    }
    public static void main(String[] args){
        Mohammad_AboHasan();
    }
}

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

public class Main {
    public static int distance(int x1,int y1,int x2,int y2){
        return (Math.abs(x1-x2)+Math.abs(y1-y2));
    }
    public static void main(String[] args) throws IOException {
    // TODO Auto-generated method stub
    Scanner S = new Scanner(System.in);
    BufferedReader BR = new BufferedReader(new InputStreamReader(System.in));
    PrintWriter PW = new PrintWriter(new OutputStreamWriter(System.out));
    String num =S.next();
    if(num.length()<=3&&Math.abs(Integer.parseInt(num))<=127){System.out.println("byte");}
    else if(num.length()<=5&&Math.abs(Integer.parseInt(num))<=32767){System.out.println("short");}
    else if(num.length()<=10&&Math.abs(Long.parseLong(num))<=Integer.MAX_VALUE){System.out.println("int");}
    else if (num.length() <= 19) {
            try{
                Long.parseLong(num);
                System.out.println("long");
            }
            catch (NumberFormatException e){
                System.out.println("BigInteger");
            }
        }
        else {System.out.println("BigInteger");}
    }

}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.InputStream;

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

    static class APetyaIJava {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            String s = in.nextString();
            try {
                long val = Long.parseLong(s);
                if (val >= -128 && val <= 127) {
                    out.println("byte");
                } else if (val >= -32768 && val <= 32767) {
                    out.println("short");
                } else if (val >= -2147483648 && val <= 2147483647) {
                    out.println("int");
                } else {
                    out.println("long");
                }
            } catch (Exception e) {
                out.println("BigInteger");
            }
        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void print(Object... objects) {
            for (int i = 0; i < objects.length; i++) {
                if (i != 0) {
                    writer.print(' ');
                }
                writer.print(objects[i]);
            }
        }

        public void println(Object... objects) {
            print(objects);
            writer.println();
        }

        public void close() {
            writer.close();
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public String nextString() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            StringBuilder res = new StringBuilder();
            do {
                if (Character.isValidCodePoint(c)) {
                    res.appendCodePoint(c);
                }
                c = read();
            } while (!isSpaceChar(c));
            return res.toString();
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }
}

/* package whatever; // don't place package name! */

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

/* Name of the class has to be "Main" only if the class is public. */
public class Main
{
    public static void main (String[] args) throws java.lang.Exception
    {

        Scanner input = new Scanner(System.in);

        BigInteger z = new BigInteger (input.nextLine());

       if ( z.compareTo( BigInteger.valueOf( -128 ) ) >= 0 && z.compareTo( BigInteger.valueOf( 127 ) ) <= 0 ) System.out.println( "byte" ); else
       if ( z.compareTo( BigInteger.valueOf( -32768 ) ) >= 0 && z.compareTo( BigInteger.valueOf( 32767 ) ) <= 0 ) System.out.println( "short" ); else
       if ( z.compareTo( BigInteger.valueOf( -2147483648 ) ) >= 0 && z.compareTo( BigInteger.valueOf( 2147483647 ) ) <= 0 ) System.out.println( "int" ); else
       if ( z.compareTo( BigInteger.valueOf( -9223372036854775808L ) ) >= 0 && z.compareTo( BigInteger.valueOf( 9223372036854775807L ) ) <= 0 ) System.out.println( "long" ); else
         System.out.println( "BigInteger" );

        input.close();

    }
}

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

public class PetyaAndJava{
    public static void main(String[] args)throws IOException{
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
        double n = Double.parseDouble(in.readLine());
        if(-128 <= n && n <= 127)
            out.println("byte");
        else if(-32768 <= n && n <= 32767)
            out.println("short");
        else if(-2147483648 <= n && n <= 2147483647)
            out.println("int");
        else if(-9223372036854775808L <= n && n <= 9223372036854775807L)
            out.println("long");
        else
            out.println("BigInteger");
        out.close();
    }
}

import java.util.*;

public class Main {

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        String x = scan.next();
        int n = 0;
        String q = "9223372036854775807";
        if (x.length() <= 3 && Integer.parseInt(x) <= 127)
            System.out.println("byte");
        if (x.length() <= 5 && Integer.parseInt(x) <= 32767 && Integer.parseInt(x) > 127)
            System.out.println("short");
        if (x.length() <= 10 && Long.parseLong(x) <= 2147483647 && Integer.parseInt(x) > 32767)
            System.out.println("int");
        else {
            if (x.length() >= 10) {
                if (x.length() < q.length())
                    System.out.println("long");
                else if (x.length() > q.length())
                    System.out.println("BigInteger");
                else {
                    int sum = 0;
                    if (x.length() == q.length()) {
                        for (int i = 0; i < x.length(); i++) {
                            sum += Integer.parseInt(q.charAt(i) + "") - Integer.parseInt(x.charAt(i) + "");
                        }
                        if (sum > 0)
                            System.out.println("BigInteger");
                        else
                            System.out.println("long");
                    }
                }
            }
        }
    }
}

import java.math.BigInteger;
import java.util.Scanner;

public class test {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        BigInteger input = BigInteger.valueOf(0);
        BigInteger Zero =  BigInteger.valueOf(0);

        @SuppressWarnings("resource")
        Scanner in = new Scanner(System.in);

        input = in.nextBigInteger() ;
        BigInteger Long = BigInteger.valueOf(2147483648L) ;
        BigInteger Int = BigInteger.valueOf(2147483647);

        if(input.intValue() < 127 && input.intValue() > -128)
            System.out.println("byte") ;
        else
            if(input.intValue() < 32767 && input.intValue() > -32768)
                System.out.println("short") ;
            else
                if(input.compareTo(Int) == -1 && input.compareTo(Int.negate()) == 1 )
                    System.out.println("int") ;
                else
                    if(input.compareTo(Long) == -1  && input.compareTo(Long.negate()) == 1 )
                        System.out.println("long") ;

                    else
                        System.out.println("BigInteger") ;
    }

}

import com.sun.org.apache.bcel.internal.Constants;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Scanner;
import java.util.StringTokenizer;

public class Hasan0504 {

    public static void main(String[] args) throws IOException {
        //  BufferedReader buffer = new BufferedReader(new InputStreamReader(System.in));

        Scanner input = new Scanner(System.in);
String a=input.next();

  if(a.length()>19)
            System.out.println("BigInteger");
 else

 {
 if(a.length()>=10){
     System.out.println("long");
 }
 else
 if(Integer.parseInt(a)>=-127 && Integer.parseInt(a)<=127)
            System.out.println("byte");
     else
     if(Integer.parseInt(a)>=-32768 && Integer.parseInt(a)<=32767)
            System.out.println("short");
 else
         if(Integer.parseInt(a)>=-2147483648 && Integer.parseInt(a)<= 2147483647)
              System.out.println("int");

   }  }}

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

import java.util.*;
import java.math.BigInteger;
/**
 *
 * @author paagol
 */
public class Main {

    /**
     * @param args the command line arguments
     */

    public static void main(String[] args){
        Scanner cin = new Scanner(System.in);
        String s = cin.nextLine();
        BigInteger b = new BigInteger(s);
        if(b.compareTo(new BigInteger("-128"))>=0 && b.compareTo(new BigInteger("127"))<=0)
            System.out.println("byte");
        else if(b.compareTo(new BigInteger("-32768"))>=0 && b.compareTo(new BigInteger("32767"))<=0 )
            System.out.println("short");
        else if(b.compareTo(new BigInteger("-2147483648"))>=0 && b.compareTo(new BigInteger("2147483647"))<=0 )
            System.out.println("int");
        else if(b.compareTo(new BigInteger("-9223372036854775808"))>=0 && b.compareTo(new BigInteger("9223372036854775808"))<=0 )
            System.out.println("long");
        else System.out.println("BigInteger");
    }
        // TODO code anpplication logic hereys

}

import java.math.BigInteger;
import java.util.Scanner;

public class A {
	public static void main(String[] args) {
		Scanner nm = new Scanner(System.in);
		String s = nm.next();
		int n = s.length();
		if (n <= 10) {
			long k = Long.parseLong(s);
			if (k >= -128 && k <= 127) {
				System.out.println("byte");
				return;
			} else {
				if (k >= -32768 && k <= 32676) {
					System.out.println("short");
					return;
				} else {
					if (k >= Integer.MIN_VALUE && k <= Integer.MAX_VALUE) {
						System.out.println("int");
						return;
					} else {
						System.out.println("long");
						return;
					}
				}
			}
		}
		BigInteger bg = new BigInteger(s);
		BigInteger min=new BigInteger(Long.MIN_VALUE+"");
		BigInteger max=new BigInteger(Long.MAX_VALUE+"");
		if (bg.compareTo(min)>=0 && bg.compareTo(max)<=0) {
			System.out.println("long");
		}else{
			System.out.println("BigInteger");
		}
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.*;

public class Main {

    private boolean check(BigInteger b , BigInteger a) {
        return b.compareTo(a) <= 0;
    }

    private void solve() throws IOException {
        BigInteger n = new BigInteger(nextToken());
        if (check(n, new BigInteger("128"))) {
            out.println("byte");
        } else if (check(n, new BigInteger("32767"))) {
            out.println("short");
        } else if (check(n, new BigInteger("2147483647"))) {
            out.println("int");
        }  else if (check(n, new BigInteger("9223372036854775807"))) {
            out.println("long");
        }  else {
            out.println("BigInteger");
        }
    }

    public static void main(String[] args) {

        try {
            br = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
            new Main().solve();
            out.close();
        } catch (Throwable e) {
            e.printStackTrace();
            System.exit(239);
        }
    }
    static BufferedReader br;
    static StringTokenizer st;
    static PrintWriter out;

    static String nextToken() throws IOException {
        while (st == null || !st.hasMoreTokens()) {
            String line = br.readLine();
            if (line == null) {
                return null;
            }
            st = new StringTokenizer(line);
        }
        return st.nextToken();
    }

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

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

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

    static int[] nextIntArray(int n) throws IOException {
        int[] temp = new int[n];
        for (int x = 0; x < n; x++) {
            temp[x] = nextInt();
        }
        return temp;
    }

    static long[] nextLongArray(int n) throws IOException {
        long[] temp = new long[n];
        for (int x = 0; x < n; x++) {
            temp[x] = nextLong();
        }
        return temp;
    }

    static String[] nextArray(int n) throws IOException {
        String[] temp = new String[n];
        for (int x = 0; x < n; x++) {
            temp[x] = nextToken();
        }
        return temp;
    }

    static <T> void debug(T x) {
        System.out.println("debug x: " + x.toString());
    }

    static void debugInt(int[] x) {
        for (int a = 0; a < x.length; a++) {
            System.out.println("debug array no: " + a + " value: " + x[a]);
        }
    }

    static void debugArray(String[] x) {
        for (int a = 0; a < x.length; a++) {
            System.out.println("debug array no: " + a + " value: " + x[a]);
        }
    }
}

import java.util.Scanner;
public class lg1 {//long:−9223372036854775808~9223372036854775807  BigInteger: -∞−∞ ~∞∞
public static void main(String args[]) {//byte: -128~127   short: −32768~32767   int: −2147483648~2147483647
	Scanner sc=new Scanner(System.in);
	String input=sc.next();
	long result=0;
	if(input.length()<=10||input.contains("−")&&input.length()<=11) {
		long a=Long.parseLong(input);
		if(a<=127&&a>=-128) {
			System.out.println("byte");
		}
		else if(a<=32767&&a>=-32768) {
			System.out.println("short");
		}
		else if(a<=2147483647&&a>=-2147483648) {
			System.out.println("int");
		}
		else {
			System.out.println("long");
		}
	}
	else if(input.length()>10&&input.length()<=19||input.contains("−")&&input.length()>11&&input.length()<=20) {
		if(input.length()>10&&input.length()<19||input.contains("−")&&input.length()>11&&input.length()<20) {
			System.out.println("long");
		}
		else if(input.length()==19||input.contains("−")&&input.length()==20) {
			if(input.contains("−")) {
				String b=input.replace("−", "");
				char c[]=new char[19];
				for(int i=0;i<19;i++) {
				  c[i]=b.charAt(i);
				}
				char d[]= {'9','2','2','3','3','7','2','0','3','6','8','5','4','7','7','5','8','0','8'};
				for(int i=0;i<19;i++) {
					result=result+c[i]-d[i];
				}
				if(result>0) {
					System.out.println("BigInteger");
				}
				else {
					System.out.println("long");
				}
			}
			else {
				char e[]=new char[19];
				for(int i=0;i<19;i++) {
					e[i]=input.charAt(i);
				}
				char f[]= {'9','2','2','3','3','7','2','0','3','6','8','5','4','7','7','5','8','0','7'};
				for(int i=0;i<19;i++) {
					result=result+e[i]-f[i];
					if(result>0) {
						System.out.println("BigInteger");
					}
					else {
						System.out.println("long");
					}
				}
			}
		}

	}else {
		System.out.println("BigInteger");
	}
}
}

import java.util.*;

public class Main {
	public static void main (String[] args) {
		String value = new Scanner(System.in).nextLine();

		try {
			long realValue = Long.parseLong(value);

			if (realValue <= Byte.MAX_VALUE && realValue >= Byte.MIN_VALUE)
				System.out.println("Byte");
			else if (realValue <= Short.MAX_VALUE && realValue >= Short.MIN_VALUE)
				System.out.println("Short");
			else if (realValue <= Integer.MAX_VALUE && realValue >= Integer.MIN_VALUE)
				System.out.println("Integer");
			else
				System.out.println("Long");
		} catch (NumberFormatException e) {
			System.out.println("BigInteger");
		}
	}
}

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);

        String res = "BigInteger";
        if (scanner.hasNextByte())
            res = "byte";
        else if (scanner.hasNextShort())
            res = "short";
        else if (scanner.hasNextInt())
            res = "int";
        System.out.println(res);
    }
}

import java.math.BigInteger;
import java.util.Scanner;
public class a
{
    public static void main(String[]args)
    {
        Scanner cin=new Scanner(System.in);
        BigInteger n=cin.nextBigInteger();
        if(new BigInteger("-128").compareTo(n)<=0&&n.compareTo(new BigInteger("127"))<=0)
            System.out.println("byte");
        if(new BigInteger("-32768").compareTo(n)<=0&&n.compareTo(new BigInteger("32767"))<=0)
            System.out.println("short");
        else if(new BigInteger("-2147483648").compareTo(n)<=0&&n.compareTo(new BigInteger("2147483647"))<=0)
            System.out.println("int");
        else if (new BigInteger("-9223372036854775808").compareTo(n) <= 0 && n.compareTo(new BigInteger("9223372036854775807")) <= 0)
            System.out.println("long");
        else
            System.out.println("Biginteger");
    }
}

//package main;

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

public class Main {

  public static void main(String[] args) {
    Scanner cin = new Scanner(System.in);
    BigInteger d = new BigInteger(cin.nextLine());
    if((d.compareTo(new BigInteger("-129")) == 1) && (d.compareTo(new BigInteger("128")) == -1))
      System.out.print("byte");
    else if((d.compareTo(new BigInteger("-32769")) == 1) && (d.compareTo(new BigInteger("32768")) == -1))
      System.out.print("short");
    else if((d.compareTo(new BigInteger("-2147493649")) == 1) && (d.compareTo(new BigInteger("2147483648")) == -1))
      System.out.print("int");
    else if((d.compareTo(new BigInteger("-9223372036854775809")) == 1) && (d.compareTo(new BigInteger("9223372036854775809")) == -1))
      System.out.print("long");
    else
      System.out.print("BigInteger");
  }
}

import java.util.Scanner;

public class Main {
    //long 19 int 10
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        char[] b = {'1','2','7'};
        char[] s = {'3','2','7','6','7'};
        char[] i = {'2','1','4','7','4','8','3','6','4','7'};
        char[] l = {'9','2','2','3','3','7','2','0','3','6','8','5','4','7','7','5','8','0','7'};
        char[] num = scanner.nextLine().toCharArray();
        if(usable(num, b)) {
            System.out.println("byte");
        } else if (usable(num, s)) {
            System.out.println("short");
        } else if (usable(num, i)) {
            System.out.println("int");
        } else if (usable(num, l)) {
            System.out.println("long");
        } else {
            System.out.println("BigInteger");
        }
    }

    public static boolean usable(char[] num, char[] boundary) {
        int len;
        if (num[0] == '-' || num[0] == '−') {
            len = num.length-1;
            boundary[boundary.length-1] = '8';
        } else if (num[0] == '+' ) {
            len = num.length-1;
            boundary[boundary.length-1] = '7';
        } else {
            len = num.length;
            boundary[boundary.length-1] = '7';
        }
        if (len < boundary.length) {
            return true;
        } else if (len > boundary.length) {
            return false;
        } else {
            for (int i = 0; i < len; i++) {
                if (num[i+num.length-len] - boundary[i] > 0) {
                    return false;
                } else if (num[i+num.length-len] - boundary[i] < 0) {
                    return true;
                }
            }
        }
        return false;
    }
}

import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author nasko
 */
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) {

        String s = in.next();

        if(s.length() == 3) {
            int q = Integer.parseInt(s);
            if(q <= 127) out.println("byte");
            else out.println("short");
        } else if(s.length() == 4) out.println("short");
        else if(s.length() == 5) {
            if(Integer.parseInt(s) <= 32767) out.println("short");
            else out.println("int");
        } else if(s.length() < 10) {
            out.println("int");
        } else if(s.length() == 10) {
            if(s.compareTo("2147483647") <= 0) {
                out.println("int");

            } else out.println("long");
        } else if(s.length() < 19) {
            out.println("long");
        } else if(s.length() == 19) {
            if(s.compareTo("9223372036854775807") <= 0) {
                out.println("long");

            } else out.println("BigInteger");
        } else out.println("BigInteger");

    }
}

class InputReader {
    public BufferedReader reader;
    public StringTokenizer tokenizer;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream));
        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();
    }

    }

        import java.util.Scanner;
public class Main {

    public static void main(String[] args) {

        Scanner  sc= new Scanner(System.in);
        Long s = sc.nextLong();
        String ss=s.toString();

        if(ss.length()<=3){
            if(s<=127 && s>=-128)
            System.out.print("byte");
        }
        else if(ss.length()<=5){
            if (s<=32767 && s>=-32768)
                System.out.print("short");
        }
        else if(ss.length()<=10){
            if (s<=2147483647 && s>=-2147483648)
                System.out.print("int");
        }
        else if(ss.length()<=19){
            System.out.print("long");
        }
        else System.out.print("BigInteger");

    }

}

import static java.lang.System.in;
import java.util.Scanner;

public class A66 {
    public static void main(String[]args){
        Scanner in = new Scanner(System.in);
        try{long x = in.nextLong();

            if(x<=127)System.out.println("byte");
            else if(x<=32767) System.out.println("short");
            else if (x<=2147483647) System.out.println("int");
            else System.out.println("long");
                }
        catch(Exception e){ System.out.println("Biginteger");
    }

}
}

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.PrintStream;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner cin = new Scanner(new BufferedInputStream(System.in));
		PrintStream cout = new PrintStream(new BufferedOutputStream(System.out));

		BigInteger n = cin.nextBigInteger();
		if (n.compareTo(new BigInteger("-9223372036854775808")) < 0
				|| n.compareTo(new BigInteger("9223372036854775807")) > 0) {
			System.out.println("BigInteger");
		} else if (n.compareTo(new BigInteger("-2147483648")) < 0 || n.compareTo(new BigInteger("2147483647")) > 0) {
			System.out.println("long");
		} else if (n.compareTo(new BigInteger("-32768")) < 0 || n.compareTo(new BigInteger("32767")) > 0) {
			System.out.println("int");
		} else if (n.compareTo(new BigInteger("-128")) < 0 || n.compareTo(new BigInteger("127")) > 0) {
			System.out.println("int");
		} else
			System.out.println("byte");

		cin.close();
		cout.close();
	}
}

import java.io.*;

import java.lang.reflect.Array;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.RoundingMode;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

public class aa {

public static void main(String[] args) {

    try{

    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    String input=""
;

input=br.readLine();
BigInteger b= new BigInteger(input);

    if(BigInteger.valueOf(-128).compareTo(b)<=0&& b.compareTo(BigInteger.valueOf(127))<=0)
    {

        System.out.print("byte");

    }

    else if(BigInteger.valueOf(-32768).compareTo(b)<=0&& b.compareTo(BigInteger.valueOf(32767))<=0)
    {

        System.out.print("short");

    }

    else if(BigInteger.valueOf(-2147483648).compareTo(b)<=0&& b.compareTo(BigInteger.valueOf(2147483647))<=0)
    {

        System.out.print("short");

    }

    else if(BigInteger.valueOf(Long.MIN_VALUE ).compareTo(b)<=0&& b.compareTo(BigInteger.valueOf(Long.MAX_VALUE))<=0)
    {

        System.out.print("long");

    }

    else {

        System.out.print("BigInteger");

    }

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

}}

import java.util.Scanner;

public class SolutionC {
    //long 19 int 10
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        char[] b = {'1','2','7'};
        char[] s = {'3','2','7','6','7'};
        char[] i = {'2','1','4','7','4','8','3','6','4','7'};
        char[] l = {'9','2','2','3','3','7','2','0','3','6','8','5','4','7','7','5','8','0','7'};
        char[] num = scanner.nextLine().toCharArray();
        if(usable(num, b)) {
            System.out.println("byte");
        } else if (usable(num, s)) {
            System.out.println("short");
        } else if (usable(num, i)) {
            System.out.println("int");
        } else if (usable(num, l)) {
            System.out.println("long");
        } else {
            System.out.println("BigInteger");
        }
    }

    public static boolean usable(char[] num, char[] boundary) {
        if (num.length < boundary.length) {
            return true;
        } else if (num.length > boundary.length) {
            return false;
        } else {
            for (int i = 0; i < num.length; i++) {
                if (num[i] - boundary[i] > 0) {
                    return false;
                }
            }
        }
        return true;
    }
}

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

public class Solution
 {
    public static void main(String args[])
     {
        Scanner sc=new Scanner(System.in);
        BigInteger val;
        BigInteger a=new BigInteger("-128");
        BigInteger b=new BigInteger("128");
        BigInteger c=new BigInteger("-32768");
        BigInteger d=new BigInteger("32767");
        BigInteger e=new BigInteger("-2147483648");
        BigInteger f=new BigInteger("2147483647");
        BigInteger g=new BigInteger("-9223372036854775808");
        BigInteger h=new BigInteger("9223372036854775807");

        val=sc.nextBigInteger();
        if(val.compareTo(a)>=0 && val.compareTo(b)<=0)
            System.out.println("byte");
        else if(val.compareTo(c)>=0 && val.compareTo(d)<=0)
            System.out.println("short");
        else if(val.compareTo(e)>=0 && val.compareTo(f)<=0)
            System.out.println("int");
        else if(val.compareTo(g)>=0 && val.compareTo(h)<=0)
            System.out.println("long");
        else
            System.out.println("BigInteger");
     }
 }

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

//this one works; C++ still too slow ?
public class petya {
	static Scanner sc;
	static int x[], l[];
	static BigInteger c;
	static int n;

	public static boolean in_range(long a, long b) {
		return c.compareTo(BigInteger.valueOf(a)) != -1 && c.compareTo(BigInteger.valueOf(b)) != 1;
	}

	public static void main(String[] args) throws IOException {
		sc = new Scanner(System.in);
		c = sc.nextBigInteger();
		if (in_range(-127L,128L)) {
			System.out.println("byte");
		} else if (in_range(-32768L,32767L)) {
			System.out.println("short");
		} else if (in_range(-2147483648L,2147483647L)) {
			System.out.println("int");
		} else if (in_range(-9223372036854775808L,9223372036854775807L)) {
			System.out.println("long");
		} else {
			System.out.println("BigInteger");
		}
	}
}

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

public class Main{

	// split de array
	public static int[] atoi(String cad) {
		String read[] = cad.split(" ");
		int res[] = new int[read.length];
		for (int i = 0; i < read.length; i++) {
			res[i] = Integer.parseInt(read[i]);
		}
		return res;
	}

	// split de String
	public static String[] atos(String cad) {
		return cad.split(" ");
	}

	// parsing de String a int
	public static int parseo(String cad, int index) {
		return Integer.parseInt(cad.split(" ")[index]);
	}

	// memory status
	static String memoryStatus() {
		return (Runtime.getRuntime().totalMemory()
				- Runtime.getRuntime().freeMemory() >> 20)
				+ "/" + (Runtime.getRuntime().totalMemory() >> 20) + " MB";
	}

	// imprimir array
	static void printArrayInt(int[] array) {
		if (array == null || array.length == 0)
			return;
		for (int i = 0; i < array.length; i++) {
			if (i > 0)
				System.out.print(" ");
			System.out.print(array[i]);
		}
		System.out.println();
	}

	// impresion de datos
	static void print(Object... obj) {
		for (int i = 0; i < obj.length; i++) {
			if (i != 0)
				System.out.print(" ");
			System.out.print(obj[i]);
		}
		System.out.println();
	}

	public static void main(String[] args) throws IOException {
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		String line = in.readLine();
		BigInteger b = new BigInteger(line);

		if (line.length() <= 11) {
			long x = Integer.parseInt(line);
			if (x >= -127 && x <= 128) {
				System.out.println("byte");
			} else if (x >= -32768 && x <= 32767) {
				System.out.println("short");
			} else if (x >= -2147483648 && x <= 2147483647) {
				System.out.println("int");
			} else
				System.out.println("long");
		} else {

			if (b.compareTo(new BigInteger("9223372036854775807")) > 0) {
				System.out.println("BigInteger");
			} else {
				System.out.println("long");
			}
		}

	}
}

import java.math.BigInteger;
import java.util.Scanner;

/**
 * @author Alexander Grigoryev
 * @version 1.0 (created on 17.07.11)
 */
public
class Codeforces {
    public static
    void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        BigInteger n = new BigInteger(scan.nextLine());

        if (n.compareTo(new BigInteger("-128")) >= 0
            && n.compareTo(new BigInteger("127")) <= 0) {
            System.out.println("byte");
        }
        else if (n.compareTo(new BigInteger("-32768")) >= 0
                 && n.compareTo(new BigInteger("32768")) <= 0) {
            System.out.println("short");
        }
        else if (n.compareTo(new BigInteger("-2147483647")) >= 0
                 && n.compareTo(new BigInteger("2147483647")) <= 0) {
            System.out.println("int");
        }
        else if (n.compareTo(new BigInteger("-9223372036854775807")) >= 0
                 && n.compareTo(new BigInteger("9223372036854775807")) <= 0) {
            System.out.println("long");
        }
        else System.out.println("BigInteger");
    }
}

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.util.Scanner;

public class Main {
    public static void main(String args[]){
        PrintWriter out = new PrintWriter(System.out);
        Scanner in = new Scanner(System.in);
        String s = in.nextLine().trim();
        boolean b = false;
        int k= s.length();
        if(s.charAt(0)=='-') {
            if(k<=19){
                long n=Long.parseLong(s);
                if(n>=-128) out.println("byte");
                else{
                    if(n>=-32768) out.println("short");
                    else{
                        if(n>=-2147483648) out.println("int");
                        else if(n>=Long.MIN_VALUE) out.println("long");

                    }
                }

            }else{
                            String str = "9223372036854775808";
                            for(int i=0; i<str.length();i++){
                                if(str.charAt(i)<s.charAt(i+1)){
                                    out.println("BigInteger");
                                    b=true;
                                    break;
                                }
                            }
                            if(!b) out.println("long");
                        }
        }
        else{
             if(k<=18){
                long n=Long.parseLong(s);
                if(n<=127) out.println("byte");
                else{
                    if(n<=32767) out.println("short");
                    else{
                        if(n<=2147483647) out.println("int");
                        else if(n<=Long.MAX_VALUE) out.println("long");

                    }
                }

            } else{
                            String str = "9223372036854775807";
                            for(int i=0; i<str.length();i++){
                                if(str.charAt(i)<s.charAt(i)){
                                    out.println("BigInteger");
                                    b=true;
                                    break;
                                }
                            }
                            if(!b) out.println("long");
                        }
        }

        out.close();
    }
}

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

public class R_60_A {

	/**
	 * @param args
	 */
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		BufferedReader r = new BufferedReader(new InputStreamReader(System.in));
		String s = r.readLine();
		BigInteger x = new BigInteger(s);
		if (x.compareTo(new BigInteger("-127")) == 1
				&& x.compareTo(new BigInteger("128")) == -1) {
			System.out.println("byte");
		} else if (x.compareTo(new BigInteger("-32767")) == 1
				&& x.compareTo(new BigInteger("32768")) == -1) {
			System.out.println("short");
		} else if (x.compareTo(new BigInteger("-2147483647")) == 1
				&& x.compareTo(new BigInteger("2147483648")) == -1) {
			System.out.println("int");
		} else if (x.compareTo(new BigInteger("9223372036854775807")) == 1
				&& x.compareTo(new BigInteger("9223372036854775808")) == -1) {
			System.out.println("long");
		} else {
			System.out.println("BigInteger");
		}
	}
}

import java.io.*;
import java.math.BigInteger;
import java.util.*;
public class Main {

	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		//PrintWriter out = new PrintWriter(System.out);
		String s = br.readLine();
		if(s.length()<=3 && Integer.parseInt(s)<=127)
			System.out.println("byte");
		else if(s.length()<=5 &&Integer.parseInt(s)<=32767)
			System.out.println("short");
		else if(s.length()<=10 &&Long.parseLong(s)<=2147483647)
			System.out.println("int");
		else if(s.length()<=19 &&new BigInteger(s).compareTo(new BigInteger(String.valueOf(2147483647)))<0)
			System.out.println("long");
		else
			System.out.println("BigInteger");
		//out.flush();
		//out.close();
		// end of main
	}

}

import java.io.BufferedReader;
import java.io.PrintWriter;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.Collection;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;

public class CF61A implements Runnable{

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

    @Override
    public void run(){
        try{
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
            tok = null;
            solve();
            in.close();
            out.close();

        }
        catch(IOException e){
            e.printStackTrace();
            System.exit(0);
        }
    }

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

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

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

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

    BufferedReader in;
    PrintWriter out;
    StringTokenizer tok;
    //////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////
    private void solve()throws IOException{
      String s = nextToken();
      if(s.length() <= 18){
          long n = Long.parseLong(s);
          if(n >= -128 && n <= 127)out.println("byte");
          else if(n >= -32768 && n <= 32767)out.println("short");
          else if(n >= Integer.MIN_VALUE && n <= Integer.MAX_VALUE) out.println("int");
          else out.println("long");
      }
      else if(s.length() > 20)out.println("BigInteger");
      else if(s.length() == 19){
          String l = "9223372036854775807";
          int i;
          for(i = 0; i < l.length(); i++){
              if(s.charAt(i) > l.charAt(i)){
                  out.println("BigInteger");
                  break;
              }
          }
          if(i == 19)out.println("long");
      }
      else if(s.length() == 20){
          String l = "-9223372036854775808";
          int i ;
          for(i = 0 ; i < 20; i++){
              if(s.charAt(i) > l.charAt(i)){
                  out.println("BigInteger");
                  break;
              }
          }

          if(i == 20)out.println("long");
      }

    }
}

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.Reader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {
    public static String fileIn = "Input.txt";
    public static String fileOut = "Output.txt";
    public static final String noNextString = "This is the end";
    public static final String noNext = "-1";

    public static void main(String[] args) throws Exception {
        PrintWriter jout = new PrintWriter(System.out);
        Scanner jin = new Scanner(new InputStreamReader(System.in));
        double n = jin.nextDouble();
        if (n <= (1 << 7) - 1)
        	System.out.println("byte");
        else if (n <= (1 << 15) - 1)
        	 System.out.println("short");
        else if (n <= (1 << 31) - 1)
        	 System.out.println("int");
        else if (n <= (1 << 63) - 1)
        	 System.out.println("long");
        else
        	 System.out.println("BigInteger");

         jout.close();
    }
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import org.omg.CORBA.DynAny;

public class APetyaAndJava {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        try {
            BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

            String str = reader.readLine().trim();

            if (str.length() <= 19 || (str.length() == 20 && str.charAt(0) == '-')) {
                long x = Long.parseLong(str);
                if (x >= -128 && x <= 127) {
                    System.out.println("byte");
                } else if (x >= -32768 && x <= 32767) {
                    System.out.println("short");
                } else if (x >= -2147483648 && x <= 2147483647) {
                    System.out.println("int");
                } else {
                    System.out.println("long");
                }
            } else {
                System.out.println("BigInteger");
            }
            reader.close();
        } catch (Exception e) {
        }
    }
}

import java.util.*;
public class datatypes {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner in = new Scanner(System.in);
		String s;
		s=in.next();
		if(s.length()<=10)
		{
			long a=Long.parseLong(s);
			a=Math.abs(a);
			if(a<=128)
			{
				System.out.println("byte");
			}
			else if(a<=32768)
			{
				System.out.println("short");
			}
			else
			{
				System.out.println("int");
			}
		}
		else if(s.length()<=19)
		{
			System.out.println("long");
		}
		else
		{
			System.out.println("BigInteger");
		}
	}
}

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

public class Main {

	/**
	 * @param args
	 * @throws FileNotFoundException
	 */
	public static void main(String[] args) throws FileNotFoundException {
		Scanner in = new Scanner(System.in);
		PrintStream out = System.out;

		BigInteger byte1 = new BigInteger("-127");
		BigInteger byte2 = new BigInteger("128");

		BigInteger short1 = new BigInteger("-32768");
		BigInteger short2 = new BigInteger("32767");

		BigInteger int1 = new BigInteger("-2147483648");
		BigInteger int2 = new BigInteger("2147483647");

		BigInteger long1 = new BigInteger("-9223372036854775808");
		BigInteger long2 = new BigInteger("9223372036854775807");

		BigInteger a = in.nextBigInteger();

		if( a.compareTo(byte1) == 1 && ( a.compareTo(byte2) == -1 ) )
			out.print("byte");
		else if( a.compareTo(short1) == 1 && ( a.compareTo(short2) == -1 ) )
			out.print("short");
		else if( a.compareTo(int1) == 1 && ( a.compareTo(int2) == -1 ) )
			out.print("int");
		else if( a.compareTo(long1) == 1 && ( a.compareTo(long2) == -1 ) )
			out.print("long");
		else out.print("BigInteger");

		in.close();
		out.close();
	}

}

import java.awt.Point;
import java.io.*;
import java.math.BigInteger;
import java.util.*;
import static java.lang.Math.*;

public class Solution66A {

        final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE")!=null;
        BufferedReader in;
        PrintWriter out;
        StringTokenizer tok = new StringTokenizer("");

        void init() throws FileNotFoundException{
                if (ONLINE_JUDGE){
                        in = new BufferedReader(new InputStreamReader(System.in));
                        out = new PrintWriter(System.out);
                }else{
                        in = new BufferedReader(new FileReader("input.txt"));
                        out = new PrintWriter("output.txt");
                }
        }

        String readString() throws IOException{
                while(!tok.hasMoreTokens()){
                        tok = new StringTokenizer(in.readLine());
                }
                return tok.nextToken();
        }

        int readInt() throws IOException{
                return Integer.parseInt(readString());
        }

        long readLong() throws IOException{
                return Long.parseLong(readString());
        }

        double readDouble() throws IOException{
                return Double.parseDouble(readString());
        }

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

        public void run(){
                try{
                        long t1 = System.currentTimeMillis();
                        init();
                        solve();
                        out.close();
                        long t2 = System.currentTimeMillis();
                        System.err.println("Time = "+(t2-t1));
                }catch (Exception e){
                        e.printStackTrace(System.err);
                        System.exit(-1);
                }
        }

        static class Utils {

                private Utils() {}

                public static void mergeSort(int[] a) {
                        mergeSort(a, 0, a.length - 1);
                }

                private static void mergeSort(int[] a, int leftIndex, int rightIndex) {
                        final int MAGIC_VALUE = 50;
                        if (leftIndex < rightIndex) {
                                if (rightIndex - leftIndex <= MAGIC_VALUE) {
                                        insertionSort(a, leftIndex, rightIndex);
                                } else {
                                        int middleIndex = (leftIndex + rightIndex) / 2;
                                        mergeSort(a, leftIndex, middleIndex);
                                        mergeSort(a, middleIndex + 1, rightIndex);
                                        merge(a, leftIndex, middleIndex, rightIndex);
                                }
                        }
                }

                private static void merge(int[] a, int leftIndex, int middleIndex, int rightIndex) {
                        int length1 = middleIndex - leftIndex + 1;
                        int length2 = rightIndex - middleIndex;
                        int[] leftArray = new int[length1];
                        int[] rightArray = new int[length2];
                        System.arraycopy(a, leftIndex, leftArray, 0, length1);
                        System.arraycopy(a, middleIndex + 1, rightArray, 0, length2);
                        for (int k = leftIndex, i = 0, j = 0; k <= rightIndex; k++) {
                                if (i == length1) {
                                        a[k] = rightArray[j++];
                                } else if (j == length2) {
                                        a[k] = leftArray[i++];
                                } else {
                                        a[k] = leftArray[i] <= rightArray[j] ? leftArray[i++] : rightArray[j++];
                                }
                        }
                }

                private static void insertionSort(int[] a, int leftIndex, int rightIndex) {
                        for (int i = leftIndex + 1; i <= rightIndex; i++) {
                                int current = a[i];
                                int j = i - 1;
                                while (j >= leftIndex && a[j] > current) {
                                        a[j + 1] = a[j];
                                        j--;
                                }
                                a[j + 1] = current;
                        }
                }
        }

        void solve() throws IOException{
        	String s = readString();

        	if(s.length() < 19){
        		long n = Long.parseLong(s);
        		if(n < 128)
        			out.println("byte");
        		else if(n <= 32767)
        			out.println("short");
        		else if(n <= 2147483647)
        			out.println("int");
        		else out.println("long");
        	}
        	if(s.length() == 19){
        		if(s.compareTo("9223372036854775807")>=0)
        			out.println("long");
        	}
        	if(s.length()>19)
        		out.println("BigInteger");

        }

        static double distance(long x1, long y1, long x2, long y2){
        	return Math.sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
        }

        static long gcd(long a, long b){
        	while(a != b){
        		if(a < b) a -=b;
        		else b -= a;
        	}
        	return a;
        }

        static long lcm(long a, long b){
        	return a * b /gcd(a, b);
        }
}

import java.math.BigInteger;
import java.util.Scanner;

public class aan {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String x=in.nextLine();
        if(x.length()<19){
        long a=Long.parseLong(x);
        if(a<=127)  System.out.println("byte");
        else
        if(a<=32767)  System.out.println("short");
        else
        if(a<=2147483647)  System.out.println("int");
        }
        else
        {
        if(x.length()==19){
        BigInteger b=new BigInteger(x+"");

        if(b.longValue()<=9223372036854775807l)
        System.out.println("long");
        else
        System.out.println("BigInteger");
        }
        else
        System.out.println("BigInteger");
        }

        }
    }

//package src;

import java.math.BigInteger;
import java.util.Scanner;

public class Task66A {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		BigInteger big = in.nextBigInteger();
		if((big.compareTo(new BigInteger(127+""))==-1)
				&&(big.compareTo(new BigInteger(-128+""))==1)){
			System.out.println("byte");
			return;
		}
		if((big.compareTo(new BigInteger(32767+""))==-1)
				&&(big.compareTo(new BigInteger(-32768+""))==1)){
			System.out.println("short");
			return;
		}
		if((big.compareTo(new BigInteger(2147483647+""))==-1)
				&&(big.compareTo(new BigInteger(-2147483648+""))==1)){
			System.out.println("int");
			return;
		}
		if((big.compareTo(new BigInteger(9223372036854775807L+""))==-1)
				&&(big.compareTo(new BigInteger(-9223372036854775808L+""))==1)){
			System.out.println("long");
			return;
		}
		else
			System.out.println("BigInteger");
	}
}

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

public class A {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		BigInteger n = scan.nextBigInteger();
		boolean neg = n.signum() == -1;
		n = n.abs(); if (neg) n = n.subtract(BigInteger.ONE);
		String[] ret = "byte, short, int, long, BigInteger".split("[ ,]+");
		int[] w = new int[]{1, 2, 4, 8};
		for (int i = 0; i < 4; i++) {
			long t = (1 << (w[i]*8-1)) - 1;
			if (n.compareTo(BigInteger.valueOf(t)) <= 0) {
				System.out.println(ret[i]);
				return;
			}
		}
		System.out.println(ret[4]);
	}
}

import java.math.BigInteger;
import java.util.Scanner;

public class A {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		String s = sc.next();
		int l = s.length();
		if (l <= 4) {
			int d = Integer.parseInt(s);
			if (d <= 127 && d >= -128)
				System.out.println("byte");
			else
				System.out.println("short");
			return;
		}
		if (l <= 6) {
			int d = Integer.parseInt(s);
			if (-32768 <= d && 32767 >= d)
				System.out.println("short");
			else
				System.out.println("int");
			return;
		}
		if (l <= 11) {
			long d = Long.parseLong(s);
			if (-2147483648 <= d && 2147483647 >= d)
				System.out.println("int");
			else
				System.out.println("long");
			return;
		}
		BigInteger d = new BigInteger(s);

		//System.out.println(d.compareTo(new BigInteger("-19223372036854775808")));
		if (d.compareTo(new BigInteger("-9223372036854775808"))>=1
				&& d.compareTo(new BigInteger("9223372036854775807"))<=1)
			System.out.println("long");
		else
			System.out.println("BigInteger");
	}
}

import java.util.*;
public class Solution{
	static Scanner sc = new Scanner(System.in);
	public static void main(String args[]){
		String s = sc.next();
		long num = 0;
		String sarr[] = {"byte","short","int","long"};
		long limit[] = {127,(long)Math.pow(2,15)-1,(long)Math.pow(2,31)-1,(long)Math.pow(2,63)-1};
		int limitptr = 0;
		//System.out.println(Arrays.toString(limit));
		for(int i=0;limitptr<limit.length&&i<s.length();i++){
			int digit = s.charAt(i)-48;
			if(limit[limitptr]-num*10<digit)
				limitptr++;
			num = num*10+digit;
		}
		if(limitptr==limit.length)
			System.out.println("BigInteger");
		else
			System.out.println(sarr[limitptr]);

	}
}

import java.io.*;

public class Main {
    static String str;
    static String[][] arr =
        new String[][] {{"byte", "127"}, {"short", "32767"}, {"int", "2147483647"}, {"long", "9223372036854775807"},
            {"BigInteger", "-1"}};
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

    public static void main(String[] args) throws IOException {
        //        br = new BufferedReader(new InputStreamReader(new FileInputStream("/Users/huangweixuan/testdata.txt")));
        str = br.readLine();
        boolean symbol = true;
        if (str.charAt(0) == '−') {
            symbol = false;
        }
        if (symbol) {
            int idx = -1;
            for (int i = 0; i < 4; ++i) {
                if (str.length() <= arr[i][1].length()) {
                    idx = i;
                    break;
                }
            }
            if (idx < 0) {
                bw.write(arr[4][0]);
                bw.close();
                return;
            }
            boolean flag = true;
            int j = 0;
            for (int i = 0; i < str.length(); ++i) {
                if (str.charAt(i) <= arr[idx][1].charAt(j++)) {
                    continue;
                }
                flag = false;
                break;
            }
            if (flag) {
                bw.write(arr[idx][0]);
            } else {
                bw.write(arr[idx + 1][0]);
            }
        } else {
            int idx = -1;
            for (int i = 0; i < 4; ++i) {
                if (str.length() - 1 <= arr[i][1].length()) {
                    idx = i;
                    break;
                }
            }
            if (idx < 0) {
                bw.write(arr[4][0]);
                bw.close();
                return;
            }
            boolean flag = true;
            int j = arr[idx][1].length() - 1;
            for (int i = str.length() - 1; i > 0; --i) {
                if (i == str.length() - 1 && str.charAt(i) <= arr[idx][1].charAt(j--) + 1) {
                    continue;
                } else if (str.charAt(i) <= arr[idx][1].charAt(j--)) {
                    continue;
                }
                flag = false;
                break;
            }
            if (flag) {
                bw.write(arr[idx][0]);
            } else {
                bw.write(arr[idx + 1][0]);
            }
        }
        bw.close();
    }
}

import java.awt.List;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
//import java.util.Scanner;
//import java.util.Scanner;
import java.util.StringTokenizer;

public class Main {

	//YOU CAN DO IT MERNA....

	public static void main(String[] args) throws IOException {

		 Scanner2 sc= new Scanner2(System.in);
		String s=sc.next();
		if(s.length()<=3&&Integer.parseInt(s)>=(-128)&&Integer.parseInt(s)<=(127))
			System.out.print("byte");
		else if(s.length()<=5&&Integer.parseInt(s)>=(-32768)&&Integer.parseInt(s)<=(32767))
			System.out.print("short");
		else if(s.length()<=9&&Integer.parseInt(s)<=(-2147483648)&&Integer.parseInt(s)>=(2147483647))
			System.out.print("int");
		else if(s.length()<=19)
			System.out.print("long");
		else if(s.length()>19)
			System.out.print("BigInteger");

		 }

}
// copyright ->Ahmed Elsagher
	class Scanner2 {
		StringTokenizer st;
		BufferedReader br;

		public Scanner2(InputStream s) {
			br = new BufferedReader(new InputStreamReader(s));
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens()) {//lma ykon fe next token mesh hyd5ol fe while bs yrg3li l token elii wrah
				st = new StringTokenizer(br.readLine());
			//System.out.println(br.readLine());
				}
			return st.nextToken();
		}

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

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

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

		public double nextDouble() throws IOException {
			String x = next();
			StringBuilder sb = new StringBuilder("0");
			double res = 0, f = 1;
			boolean dec = false, neg = false;
			int start = 0;
			if (x.charAt(0) == '-') {
				neg = true;
				start++;
			}
			for (int i = start; i < x.length(); i++)
				if (x.charAt(i) == '.') {
					res = Long.parseLong(sb.toString());
					sb = new StringBuilder("0");
					dec = true;
				} else {
					sb.append(x.charAt(i));
					if (dec)
						f *= 10;
				}
			res += Long.parseLong(sb.toString()) / f;
			return res * (neg ? -1 : 1);
		}

		public boolean ready() throws IOException {
			return br.ready() || st.hasMoreTokens();//an br ready y3ni fe line tany w st 3ndha tokens (y3ni rg3ly next token bs mtd5olesh fe while)

		}}

import java.math.BigInteger;
import java.util.Scanner;

public class Main {

    public static void main(String [] args) {

        Scanner in = new Scanner (System.in);
        BigInteger r =in.nextBigInteger();
        if (r.compareTo(BigInteger.valueOf(128))==-1 && r.compareTo(BigInteger.valueOf(-129))==1)
        {
            System.out.println("byte");
        }
        else if (r.compareTo(BigInteger.valueOf(32768))==-1 && r.compareTo(BigInteger.valueOf(-32768))==1)
        {
            System.out.println("short");
        }
        else if (r.compareTo(BigInteger.valueOf(2147483648L))==-1 && r.compareTo(BigInteger.valueOf(2147483649L))==1)
        {
            System.out.println("int");
        }
        else if (r.compareTo(new BigInteger("9223372036854775808"))==-1 && r.compareTo(new BigInteger("-9223372036854775809"))==1){
            System.out.println("long");
        }
        else
        {
            System.out.println("BigInteger");
        }
    }
}

import java.io.*;

import java.lang.reflect.Array;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.RoundingMode;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

public class aa {

public static void main(String[] args) {

    try{
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    String input=""
;

input=br.readLine();
BigInteger b= new BigInteger(input);

    if(BigInteger.valueOf(-127).compareTo(b)<=0&& b.compareTo(BigInteger.valueOf(128))<=0)
    {

        System.out.print("byte");

    }

    else if(BigInteger.valueOf(-32768).compareTo(b)<=0&& b.compareTo(BigInteger.valueOf(32767))<=0)
    {

        System.out.print("short");

    }

    else if(BigInteger.valueOf(-2147483648 ).compareTo(b)<=0&& b.compareTo(BigInteger.valueOf(2147483647))<=0)
    {

        System.out.print("long");

    }

    else {

        System.out.print("BigInteger");

    }

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

}}

import java.io.*;
import java.math.BigInteger;
import java.util.*;
import java.lang.*;
import static java.lang.Math.*;

public class TaskA implements Runnable {
    long m = (int)1e9+7;
    PrintWriter w;
    InputReader c;
    final int MAXN = (int)1e6 + 100;

    public void run() {
        c = new InputReader(System.in);
        w = new PrintWriter(System.out);

        BigInteger b = new BigInteger(c.next());
        if(b.compareTo(new BigInteger("127")) <=0){
            w.println("byte");
        }
        else if(b.compareTo(new BigInteger("326767")) <= 0){
            w.println("short");
        }
        else if(b.compareTo(new BigInteger("2147483647")) <= 0){
            w.println("int");
        }
        else if(b.compareTo(new BigInteger("9223372036854775807")) <= 0){
            w.println("long");
        }
        else{
            w.println("BigInteger");
        }

        w.close();
    }

    class pair implements Comparable<pair>{
        int x,y;

        public pair(int x, int y) {
            this.x = x;
            this.y = y;
        }

        @Override
        public String toString() {
            return x +
                    " " + y;
        }

        @Override
        public int compareTo(pair o) {
            return o.x - this.x;
        }
    }
    long gcd(long a, long b) {
        if (b == 0)
            return a;
        return gcd(b, a % b);
    }
    public static void sortbyColumn(int arr[][], int col){
        Arrays.sort(arr, new Comparator<int[]>()
        {
            public int compare(int[] o1, int[] o2){
                return(Integer.valueOf(o1[col]).compareTo(o2[col]));
            }
        });

    }
    public static class DJSet {
        public int[] upper;

        public DJSet(int n) {
            upper = new int[n];
            Arrays.fill(upper, -1);
        }

        public int root(int x) {
            return upper[x] < 0 ? x : (upper[x] = root(upper[x]));
        }

        public boolean equiv(int x, int y) {
            return root(x) == root(y);
        }

        public boolean union(int x, int y) {
            x = root(x);
            y = root(y);
            if (x != y) {
                if (upper[y] < upper[x]) {
                    int d = x;
                    x = y;
                    y = d;
                }
                upper[x] += upper[y];
                upper[y] = x;
            }
            return x == y;
        }
    }
    public static int[] radixSort(int[] f)    {
        int[] to = new int[f.length];
        {
            int[] b = new int[65537];
            for(int i = 0;i < f.length;i++)b[1+(f[i]&0xffff)]++;
            for(int i = 1;i <= 65536;i++)b[i]+=b[i-1];
            for(int i = 0;i < f.length;i++)to[b[f[i]&0xffff]++] = f[i];
            int[] d = f; f = to;to = d;
        }
        {
            int[] b = new int[65537];
            for(int i = 0;i < f.length;i++)b[1+(f[i]>>>16)]++;
            for(int i = 1;i <= 65536;i++)b[i]+=b[i-1];
            for(int i = 0;i < f.length;i++)to[b[f[i]>>>16]++] = f[i];
            int[] d = f; f = to;to = d;
        }
        return f;
    }
    public void printArray(int[] a, int d){
        for(int i=0;i<a.length;i++)
            w.print(a[i]+d+" ");
        w.println();
    }
    public int[] scanArrayI(int n){
        int a[] = new int[n];
        for(int i=0;i<n;i++)
            a[i] = c.nextInt();
        return a;
    }
    public long[] scanArrayL(int n){
        long a[] = new long[n];
        for(int i=0;i<n;i++)
            a[i] = c.nextLong();
        return a;
    }
    public void printArray(long[] a){
        for(int i=0;i<a.length;i++)
            w.print(a[i]+" ");
        w.println();
    }
    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private SpaceCharFilter filter;
        private BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars==-1)
                throw new InputMismatchException();

            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                }
                catch (IOException e) {
                    throw new InputMismatchException();
                }

                if(numChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }

        public String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            }
            catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
        public int nextInt() {
            int c = read();

            while(isSpaceChar(c))
                c = read();

            int sgn = 1;

            if (c == '-') {
                sgn = -1;
                c = read();
            }

            int res = 0;
            do {
                if(c<'0'||c>'9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            while (!isSpaceChar(c));

            return res * sgn;
        }

        public long nextLong() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            long res = 0;

            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            while (!isSpaceChar(c));
            return res * sgn;
        }

        public double nextDouble() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            double res = 0;
            while (!isSpaceChar(c) && c != '.') {
                if (c == 'e' || c == 'E')
                    return res * Math.pow(10, nextInt());
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            if (c == '.') {
                c = read();
                double m = 1;
                while (!isSpaceChar(c)) {
                    if (c == 'e' || c == 'E')
                        return res * Math.pow(10, nextInt());
                    if (c < '0' || c > '9')
                        throw new InputMismatchException();
                    m /= 10;
                    res += (c - '0') * m;
                    c = read();
                }
            }
            return res * sgn;
        }

        public String readString() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            }
            while (!isSpaceChar(c));

            return res.toString();
        }

        public boolean isSpaceChar(int c) {
            if (filter != null)
                return filter.isSpaceChar(c);
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public String next() {
            return readString();
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);
        }
    }
    public static void main(String args[]) throws Exception {
        new Thread(null, new TaskA(),"TaskA",1<<26).start();
    }
}

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

public class Solution
 {
    public static void main(String args[])
     {
        Scanner sc=new Scanner(System.in);
        BigInteger val;
        BigInteger a=new BigInteger("-128");
        BigInteger b=new BigInteger("128");
        BigInteger c=new BigInteger("-32768");
        BigInteger d=new BigInteger("32767");
        BigInteger e=new BigInteger("-2147483648");
        BigInteger f=new BigInteger("2147483647");
        BigInteger g=new BigInteger("-9223372036854775808");
        BigInteger h=new BigInteger("9223372036854775807");

        val=sc.nextBigInteger();
        if(val.compareTo(a)>=0 && val.compareTo(b)<=0)
            System.out.println("byte");
        else if(val.compareTo(c)>=0 && val.compareTo(d)<=0)
            System.out.println("short");
        else if(val.compareTo(e)>=0 && val.compareTo(f)<=0)
            System.out.println("int");
        else if(val.compareTo(g)>=0 && val.compareTo(h)<=0)
            System.out.println("long");
        else
            System.out.println("BigInteger");
     }
 }

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.math.BigInteger;

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

      BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
      String line = br.readLine().trim();
      long  num  ;
     // if (line.length() <= 10){
       num = Long.parseLong(line);

      if (num >= -128  && num <= 127)
          System.out.println ("byte");
      else
           if (num >= -32768   &&  num <= 32767 )
          System.out.println ("short");
           else
           if (num >= -2147483648 &&  num <= 2147483647)

          System.out.println ("int");
      else
               if ( num <=9223372036854775807l )
           System.out.println ("long");

  //  }
      else
   //  if (line.length()> 19)

         System.out.println ("biginteger");
    // else
    //   System.out.println ("long");

}

      catch (Exception e){}

  }

}

import java.io.InputStreamReader;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.math.BigInteger;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Bolat Kazybayev
 */
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) {
        String n = in.next();
        int length = n.length();
        if (length <= 3) {
            if (Short.parseShort(n) >= Byte.MIN_VALUE && Short.parseShort(n) <= Byte.MAX_VALUE)
                out.println("byte");
            else
                out.println("short");
        } else if (length <= 5) {
            if (Integer.parseInt(n) >= Short.MIN_VALUE && Integer.parseInt(n) <= Short.MAX_VALUE)
                out.println("short");
            else
                out.println("int");
        } else if (length <= 10) {
            if (Long.parseLong(n) >= Integer.MIN_VALUE  && Long.parseLong(n) <= Integer.MAX_VALUE)
                out.println("int");
            else
                out.println("long");
        } else if (length <= 19) {
            BigInteger min = new BigInteger(n);
            BigInteger minLong = new BigInteger("-9223372036854775808");
            BigInteger maxLong = new BigInteger("9223372036854775807");
            if ((min.compareTo(minLong) == 1 || min.compareTo(minLong) == 0) &&
                (min.compareTo(maxLong) == -1 || min.compareTo(maxLong) == 0))
                out.println("long");
        } else
            out.println("BigInteger");
	}
}

class InputReader {
    private BufferedReader reader;
    private StringTokenizer tokenizer;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream));
        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();
    }

    }

import java.io.*;
import java.math.BigInteger;
import java.util.*;
public class Main {

	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		//PrintWriter out = new PrintWriter(System.out);
		String s = br.readLine();
		if(s.length()<=3 && Integer.parseInt(s)<=127)
			System.out.println("byte");
		else if(s.length()<=5 &&Integer.parseInt(s)<=32767)
			System.out.println("short");
		else if(s.length()<=10 &&Long.parseLong(s)<=2147483647)
			System.out.println("int");
		else if(s.length()<=19 &&new BigInteger(s).compareTo(new BigInteger(String.valueOf(2147483647)))>=0)
			System.out.println("long");
		else
			System.out.println("BigInteger");
		//out.flush();
		//out.close();
		// end of main
	}

}

        import java.util.Scanner;
public class Main {

    public static void main(String[] args) {

        Scanner  sc= new Scanner(System.in);
        Long s = sc.nextLong();
        String ss=s.toString();

        if(ss.length()<=3){
            if(s<=127 && s>=-128)
            System.out.print("byte");
        }
        else if(ss.length()<=5){
            if (s<=32767 && s>=-32768)
                System.out.print("short");
        }
        else if(ss.length()<=10){
            if (s<=2147483647 && s>=-2147483648)
                System.out.print("int");
        }
        else if(ss.length()<=19){
            System.out.print("long");
        }
        else System.out.print("BigInteger");

    }

}

import com.sun.org.apache.bcel.internal.Constants;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Scanner;
import java.util.StringTokenizer;

public class Hasan0504 {

    public static void main(String[] args) throws IOException {
        //  BufferedReader buffer = new BufferedReader(new InputStreamReader(System.in));

        Scanner input = new Scanner(System.in);
String a=input.next();

  if(a.length()>19)
            System.out.println("BigInteger");
 else

 {
 if(a.length()>=10){
     System.out.println("long");
 }
 else
 if(Integer.parseInt(a)>=-127 && Integer.parseInt(a)<=127)
            System.out.println("byte");
     else
     if(Integer.parseInt(a)>=-32768 && Integer.parseInt(a)<=32767)
            System.out.println("short");
 else
         if(Integer.parseInt(a)>=-2147483648 && Integer.parseInt(a)<= 2147483647)
              System.out.println("int");

   }  }}

import java.math.BigInteger;
import java.util.Scanner;

public class JavaApplication9 {

    public static void main(String[] args) {
        // TODO code application logic here
        Scanner sc = new Scanner (System.in);
        try {
            String s = sc.next();
            BigInteger b = new BigInteger(s);
            long l = Integer.parseInt(s);
            int i = Integer.parseInt(s);
            int y = -32768;
            if ((i<=127) && (i>=-128)) {
                System.out.println("byte");
            }
            else if (i<=32767 && i>=y){
                System.out.println("short");
            }
            else
                System.out.println("int");
        }catch(Exception e){
            System.out.println("BigInteger");
        }

    }

}

import java.math.BigInteger;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        BigInteger b = new BigInteger(sc.nextLine()) ;

        if (b.compareTo(new BigInteger ("-128")) > -1 && b.compareTo(new BigInteger ("-127")) < 1)
            System.out.println("byte");
        else if (b.compareTo(new BigInteger ("-32768")) > -1 && b.compareTo(new BigInteger ("-32767")) < 1)
            System.out.println("short");
        else if (b.compareTo(new BigInteger ("-2147483648")) > -1 && b.compareTo(new BigInteger ("-2147483647")) < 1)
            System.out.println("int");
        else if (b.compareTo(new BigInteger ("-9223372036854775808")) > -1 && b.compareTo(new BigInteger ("-9223372036854775807")) < 1)
            System.out.println("long");
        else
            System.out.println("BigInteger");

        sc.close();
    }

}

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

public class Main {
    public static int distance(int x1,int y1,int x2,int y2){
        return (Math.abs(x1-x2)+Math.abs(y1-y2));
    }
    public static void main(String[] args) throws IOException {
    // TODO Auto-generated method stub
    Scanner S = new Scanner(System.in);
    BufferedReader BR = new BufferedReader(new InputStreamReader(System.in));
    PrintWriter PW = new PrintWriter(new OutputStreamWriter(System.out));
    String num =S.next();
    if(num.length()<=3){System.out.println("byte");}
    else if(num.length()<=5){System.out.println("short");}
    else if(num.length()<=10){System.out.println("int");}
    else if(num.length()<=19){System.out.println("long");}
    else {System.out.println("BigInteger");}
    }

}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import org.omg.CORBA.DynAny;

public class APetyaAndJava {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        try {
            BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

            String str = reader.readLine().trim();

            if (str.length() <= 19 || (str.length() == 20 && str.charAt(0) == '-')) {
                long x = Long.parseLong(str);
                if (x >= -128 && x <= 127) {
                    System.out.println("byte");
                } else if (x >= -32768 && x <= 32768) {
                    System.out.println("short");
                } else if (x >= -2147483648 && x <= 2147483647) {
                    System.out.println("int");
                } else {
                    System.out.println("long");
                }
            } else {
                System.out.println("BigInteger");
            }
            reader.close();
        } catch (Exception e) {
        }
    }
}

import java.math.BigInteger;
import java.util.Scanner;

/**
 *
 * @author Ahmed
 */
public class PetyaAndJava {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        Scanner s=new Scanner(System.in);

       String z= s.next();

if(type(z))
{
            long x = Long.parseLong(z);

        if (x >= -128 &&  x <=127)
        {
            System.out.println("byte");
        }
       else if (x >= 32767 &&  x <= 32767)
        {
            System.out.println("short");
        }
       else if (x >= -2147483648  &&  x <=2147483647)
        {
            System.out.println("int");
        }
       else if (x >= -9223372036854775808l   &&  x <= 9223372036854775807l)
        {
            System.out.println("long");
        }
}
        else
            System.out.println("BigInteger");

    }
    public static boolean type (String l){
    try{
    long x = Long.parseLong(l);
    return true;

    }
    catch(Exception e){ return false ;}
    }
}

import java.math.BigInteger;
import java.util.Scanner;

public class Acm1 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
      Scanner sc=new Scanner(System.in);
       String  number;

    number=sc.next();
    BigInteger bigInteger2 = new BigInteger (number);
    BigInteger bigInteger3 = new BigInteger ("-9223372036854775808");
    BigInteger bigInteger4 = new BigInteger ("9223372036854775807");

        int compareTo = bigInteger2.compareTo(bigInteger3);
        int compareTo2 = bigInteger2.compareTo(bigInteger4);

      if(bigInteger2.longValue()>=-128&&bigInteger2.longValue()<=127)
     System.out.println("byte");

      else  if(bigInteger2.longValue()>=-32768&&bigInteger2.longValue()<=32767)
       System.out.println("short");

      else  if(bigInteger2.longValue()>=-2147483648 &&bigInteger2.longValue()<=2147483647)
      System.out.println("int");

     else  if(compareTo2==1&&compareTo2==-1)
      System.out.println("long");

     else
        System.out.println("BigInteger");

    }
}

import java.math.BigInteger;
import java.util.Scanner;

public class Prob066A
{
    public static void main( String[] Args )
    {
        Scanner scan = new Scanner( System.in );
        BigInteger bi = new BigInteger( scan.next() );
        if ( bi.compareTo( BigInteger.valueOf( Byte.MIN_VALUE ) ) >= 0
            && bi.compareTo( BigInteger.valueOf( Byte.MAX_VALUE ) ) <= 0 )
            System.out.println( "byte" );
        else if ( bi.compareTo( BigInteger.valueOf( Short.MIN_VALUE ) ) >= 0
            && bi.compareTo( BigInteger.valueOf( Short.MAX_VALUE ) ) <= 0 )
            System.out.println( "short" );
        else if ( bi.compareTo( BigInteger.valueOf( Integer.MIN_VALUE ) ) >= 0
            && bi.compareTo( BigInteger.valueOf( Integer.MAX_VALUE ) ) <= 0 )
            System.out.println( "integer" );
        else if ( bi.compareTo( BigInteger.valueOf( Long.MIN_VALUE ) ) >= 0
            && bi.compareTo( BigInteger.valueOf( Long.MAX_VALUE ) ) <= 0 )
            System.out.println( "long" );
        else
            System.out.println( "BigInteger" );
    }
}

import java.awt.List;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
//import java.util.Scanner;
//import java.util.Scanner;
import java.util.StringTokenizer;

public class Main {

	//YOU CAN DO IT MERNA....

	public static void main(String[] args) throws IOException {

		 Scanner2 sc= new Scanner2(System.in);
		String s=sc.next();
		if(s.length()<=3&&Integer.parseInt(s)>=(-128)&&Integer.parseInt(s)<=(127))
			System.out.print("byte");
		else if(s.length()<=5&&Integer.parseInt(s)>=(-32768)&&Integer.parseInt(s)<=(32767))
			System.out.print("short");
		else if(s.length()<=9&&Integer.parseInt(s)<=(-2147483648)&&Integer.parseInt(s)>=(2147483647))
			System.out.print("int");
		else if(s.length()<=19)
			System.out.print("long");
		else if(s.length()>19)
			System.out.print("bigInteger");

		 }

}
// copyright ->Ahmed Elsagher
	class Scanner2 {
		StringTokenizer st;
		BufferedReader br;

		public Scanner2(InputStream s) {
			br = new BufferedReader(new InputStreamReader(s));
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens()) {//lma ykon fe next token mesh hyd5ol fe while bs yrg3li l token elii wrah
				st = new StringTokenizer(br.readLine());
			//System.out.println(br.readLine());
				}
			return st.nextToken();
		}

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

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

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

		public double nextDouble() throws IOException {
			String x = next();
			StringBuilder sb = new StringBuilder("0");
			double res = 0, f = 1;
			boolean dec = false, neg = false;
			int start = 0;
			if (x.charAt(0) == '-') {
				neg = true;
				start++;
			}
			for (int i = start; i < x.length(); i++)
				if (x.charAt(i) == '.') {
					res = Long.parseLong(sb.toString());
					sb = new StringBuilder("0");
					dec = true;
				} else {
					sb.append(x.charAt(i));
					if (dec)
						f *= 10;
				}
			res += Long.parseLong(sb.toString()) / f;
			return res * (neg ? -1 : 1);
		}

		public boolean ready() throws IOException {
			return br.ready() || st.hasMoreTokens();//an br ready y3ni fe line tany w st 3ndha tokens (y3ni rg3ly next token bs mtd5olesh fe while)

		}}

import java.util.*;
import java.lang.*;
import java.io.*;
public class Petya_and_java {

	public static void main(String[] args)  throws java.lang.Exception{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		try {
			long n=Long.parseLong(br.readLine());
			if(n<=Byte.MAX_VALUE) System.out.println("byte");
			else if(n<=Short.MAX_VALUE) System.out.println("short");
			else if(n<=Integer.MAX_VALUE) System.out.println("byte");
			else System.out.println("long");
		}catch(Exception e) {
			System.out.println("BigInteger");
		}
	}

}

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Scanner;

public class main {

    public static void main (String args[]) {

        Scanner in = new Scanner(System.in);

        int i = in.nextInt();

        if(i> -128 && i<127)
            System.out.println("byte");
        else if (i> -32768  && i<32767)
            System.out.println("short");
        else if (i> -2147483648   && i<2147483647)
            System.out.println("int");
        else if (i> -9223372036854775808L   && i<9223372036854775807L)
            System.out.println("long");
        else
            System.out.println("BigInteger");
    }
}

import java.math.BigInteger;
import java.util.Scanner;

public class test {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        BigInteger input = BigInteger.valueOf(0);
        BigInteger Zero =  BigInteger.valueOf(0);

        @SuppressWarnings("resource")
        Scanner in = new Scanner(System.in);

        input = in.nextBigInteger() ;
        BigInteger Long = BigInteger.valueOf(2147483648L) ;
        BigInteger Int = BigInteger.valueOf(2147483647);

        if(input.intValue() <= 127 && input.intValue() >= -128)
            System.out.println("byte") ;
        else
            if(input.intValue() <= 32767 && input.intValue() >= -32768)
                System.out.println("short") ;
            else
                if((input.compareTo(Int) == -1 || input.compareTo(Int) == 0) &&( input.compareTo(Int.negate()) == 1 || input.compareTo(Int.negate()) == 0))
                    System.out.println("int") ;
                else
                    if((input.compareTo(Long) == -1 || input.compareTo(Long) == 0) && ( input.compareTo(Long.negate()) == 1 || input.compareTo(Long.negate()) == 0))
                        System.out.println("long") ;

                    else
                        System.out.println("BigInteger") ;
    }

}

import java.math.BigInteger;
import java.util.Scanner;

public class A_Petya_and_Java {
public static void main(String[] args) {
	Scanner sc=new Scanner(System.in);
	BigInteger n= sc.nextBigInteger();
	if(new BigInteger("127").compareTo(n)>=0 && new BigInteger("-127").compareTo(n)<=0)	{	System.out.println("byte"); return;}
	if(new BigInteger("32767").compareTo(n)>=0 && new BigInteger("-32768").compareTo(n)<=0)	{	System.out.println("short"); return;}
	if(new BigInteger("2147483647").compareTo(n)>=0 && new BigInteger("-2147483648").compareTo(n)<=0)	{	System.out.println("int"); return;}
	if(new BigInteger("9223372036854775807").compareTo(n)>=0 && new BigInteger("-9223372036854775808").compareTo(n)<=0)	{	System.out.println("long"); return;}
	System.out.println("Biginteger");
}
}

import java.util.*;

public class Trying
{
    public static void main (String[] args)
    {
        Scanner enter = new Scanner(System.in);
        String n = enter.next(), poslong = "9223372036854775807",
        neglong = "9223372036854775808";
        if(n.length() <= 3 && Long.parseLong(n) <= 127
                && Long.parseLong(n) >= -128)
            System.out.println("byte");
        else if(n.length() <= 5 && Long.parseLong(n) <= 32767
                && Long.parseLong(n) >= -32768)
            System.out.println("short");
        else if(n.length() <= 10 && Long.parseLong(n) <= 2147483647
                && Long.parseLong(n) >= -2147483648)
            System.out.println("int");
        else if(n.length() <= 20 && n.charAt(0) == '-')
        {
                for(int i = 1 ; i < n.length(); i++)
                {
                    if(n.charAt(i) > neglong.charAt(neglong.length()-(n.length())+i))
                    {
                        System.out.println("BigInteger");
                        System.exit(0);
                    }
                    else if(n.charAt(i) < neglong.charAt(neglong.length()-(n.length())+i))
                    {
                        System.out.println("long");
                        System.exit(0);
                    }
                }
                System.out.println("long");
        }
        else if(n.length() <= 19)
        {
                for(int i = 0 ; i < n.length(); i++)
                {
                    if(n.charAt(i) > poslong.charAt(neglong.length()-(n.length())+i))
                    {
                        System.out.println("BigInteger");
                        System.exit(0);
                    }
                    else if(n.charAt(i) < poslong.charAt(neglong.length()-(n.length())+i))
                    {
                        System.out.println("long");
                        System.exit(0);
                    }
                }
                System.out.println("long");
        }
        else
            System.out.println("BigInteger");
    }
}

import java.math.BigInteger;
import java.util.Scanner;

public class aan {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String x=in.nextLine();
        if(x.length()<19){
        long a=Long.parseLong(x);
        if(a<=127)  System.out.println("byte");
        else
        if(a<=32767)  System.out.println("short");
        else
        if(a<=2147483647)  System.out.println("int");
        }
        else
        {
        if(x.length()==19){
        BigInteger b=new BigInteger(x+"");

        if(b.longValue()<=9223372036854775807l)
        System.out.println("long");
        else
        System.out.println("BigInteger");
        }
        else
        System.out.println("BigInteger");
        }

        }
    }

import com.sun.org.apache.bcel.internal.Constants;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Scanner;
import java.util.StringTokenizer;

public class Hasan0504 {

    public static void main(String[] args) throws IOException {
        //  BufferedReader buffer = new BufferedReader(new InputStreamReader(System.in));

        Scanner input = new Scanner(System.in);
String a=input.next();

try{
  if(a.length()>19)
            System.out.println("BigInteger");
 else

 {
 if(a.length()>10){
     System.out.println("long");
 }

 else
 if(Integer.parseInt(a)>=-127 && Integer.parseInt(a)<=127)
            System.out.println("byte");
     else
     if(Integer.parseInt(a)>=-32768 && Integer.parseInt(a)<=32767)
            System.out.println("short");
 else
         if(Integer.parseInt(a)>=-2147483648 && Integer.parseInt(a)<= 2147483647)
              System.out.println("int");

  }  }catch(Exception v){System.out.println("long");}}}

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.Reader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {
    public static String fileIn = "Input.txt";
    public static String fileOut = "Output.txt";
    public static final String noNextString = "This is the end";
    public static final String noNext = "-1";

    public static void main(String[] args) throws Exception {
        PrintWriter jout = new PrintWriter(System.out);
        Scanner jin = new Scanner(new InputStreamReader(System.in));
        String in = jin.next();
        if (in.compareTo("-128") >= 0 && in.compareTo("127") <= 0 ) {
        	jout.println("byte");
        } else if (in.compareTo("-32768") >= 0 && in.compareTo("32767") <= 0) {
        	jout.println("short");
        } else if (in.compareTo("-2147483648") >= 0 && in.compareTo("2147483647") <= 0) {
            	jout.println("int");
        } else if (in.compareTo("-9223372036854775808") >= 0 && in.compareTo("9223372036854775807") <= 0) {
        	jout.println("long");
        } else {
        	jout.println("BigInteger");
        }

        jout.close();
    }

}

//Problem 3
import java.util.*;

public class Main {

    public static Boolean isByte( String n ){
        if(isBigInt(n) == true){
            return false;
        }

        long num = Long.parseLong(n);
        long a = -128;
        long b = 127;

        if(num >= a && num <= b ){
            return true;
        } else
            return false;

    }

    public static Boolean isShort(String n){
        if(isBigInt(n) == true){
            return false;
        }

        long num = Long.parseLong(n);
        long a = -32768 ;
        long b = 32767;

        if(num >= a && num <= b ){
            return true;
        }else
            return false;

    }

    public static Boolean isInt(String n){
        if(isBigInt(n) == true){
            return false;
        }

        long num = Long.parseLong(n);
        long a = -2147483648 ;
        long b = 2147483647;

        if(num >= a && num <= b ){
            return true;
        }else
            return false;
    }

    public static Boolean isLong(String n){
        if(isBigInt(n) == true){
            return false;
        }

        long num = Long.parseLong(n);
        long a = -9223372036854775808L;
        long b = 9223372036854775807L;

        if(num <= b){
            return true;
        }else
            return false;
    }

    public static Boolean isBigInt(String n){

        String l0ng = "9223372036854775807";

        if(n.length() >= 19) {
            if(n.length() > 19) {
                return true;
            } else {
                for(int i = 0; i < n.length(); i++) {
                    if(n.charAt(i) == l0ng.charAt(i)) {
                        continue;
                    } else {
                        String x = Character.toString(n.charAt(i));
                        String y = Character.toString(l0ng.charAt(i));
                        int a = Integer.parseInt(x);
                        int b = Integer.parseInt(y);
                        if(a >= b) {
                            return true;

                        }
                    }
                }
            }
         }
         return false;
    }

    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        String n = scan.nextLine();

            if( isByte(n) == true){
                System.out.println("byte");
            }else if(isShort(n) == true){
                System.out.println("short");
            }else if (isInt(n) == true){
                System.out.println("int");
            }else if (isLong(n) == true){
                System.out.println("long");
            }else if(isBigInt(n) == true){
                System.out.println("BigInteger");
            }

            //System.out.print("WHATS HAPPENING");
    }
}

import java.util.*;

public class Main {

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        String x = scan.next();
        int n = 0;
        String q = "9223372036854775807";
        if (x.length() <= 3 && Integer.parseInt(x) <= 127)
            System.out.println("byte");
        if (x.length() <= 5 && Integer.parseInt(x) <= 32767 && Integer.parseInt(x) > 127)
            System.out.println("short");
        if (x.length() <= 10 && Long.parseLong(x) <= 2147483647 && Integer.parseInt(x) > 32767)
            System.out.println("int");
        else {
            if (x.length() >= 10) {
                if (x.length() < q.length())
                    System.out.println("long");
                else if (x.length() > q.length())
                    System.out.println("BigInteger");
                else {
                    int sum = 0;
                    if (x.length() == q.length()) {
                        for (int i = 0; i < x.length(); i++) {
                            sum += Integer.parseInt(q.charAt(i) + "") - Integer.parseInt(x.charAt(i) + "");
                        }
                        if (sum > 0)
                            System.out.println("BigInteger");
                        else
                            System.out.println("long");
                    }
                }
            }
        }
    }
}

import java.util.*;
//warm-up
public class PetyaAndJava {

    // Could just be handled using BigInteger library i guess.
    // But handled it as a string problem.
    static boolean isOverFlow(String a, String b, boolean neg){
        int len = a.length(), i = 0;
        boolean greater = false;
        while (i<len) {
            if (Character.getNumericValue(a.charAt(i))>Character.getNumericValue(b.charAt(i++))) {
                greater = true; break;
            }
        }
        greater=(neg&&greater&&(i==len))
                ? !(Character.getNumericValue(a.charAt(i-1))-1==Character.getNumericValue(b.charAt(i-1)))
                : greater;
        return greater;
    }

    static void solve(){
        Scanner sc = new Scanner(System.in);
        String tok = sc.next(), t = null;
        boolean neg = (tok.charAt(0)=='-');
        if (neg) tok = tok.substring(1);
        int len = tok.length();
        if (len>19) t="Biginteger";
        else if (len>10 && len<20) if (len==19) {
            t = (isOverFlow(tok,""+Long.MAX_VALUE, neg)) ? "Biginteger" : "long";
        } else {
            t="long";
        }
        else if (len>5 && len<=10)  if (len==10) {
            t = (isOverFlow(tok,""+Integer.MAX_VALUE, neg)) ? "long" : "int";
        } else {
            t="int";
        }
        else if (len>3 && len<=5)   if (len==5) {
            t = (isOverFlow(tok,""+Short.MAX_VALUE, neg)) ? "int" : "short";
        } else {
            t="short";
        }
        else if (len<=3) if (len==3) {
            t = (isOverFlow(tok,""+Byte.MAX_VALUE, neg)) ? "short" : "byte";
        } else {
            t="byte";
        }
        System.out.println(t);
        sc.close();
    }

    public static void main(String args[]) {
        solve();
    }
}

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

public class Main {
    public static int distance(int x1,int y1,int x2,int y2){
        return (Math.abs(x1-x2)+Math.abs(y1-y2));
    }
    public static void main(String[] args) throws IOException {
    // TODO Auto-generated method stub
    Scanner S = new Scanner(System.in);
    BufferedReader BR = new BufferedReader(new InputStreamReader(System.in));
    PrintWriter PW = new PrintWriter(new OutputStreamWriter(System.out));
    String num =S.next();
    if(num.length()<=3){System.out.println("byte");}
    else if(num.length()<=5){System.out.println("short");}
    else if(num.length()<=10){System.out.println("int");}
    else if(num.length()<=19){System.out.println("long");}
    else {System.out.println("BigInteger");}
    }

}

import java.util.Scanner;
public class MainCode
{
    public static void main (String[] args)
    {
        Scanner Input = new Scanner(System.in);
        String Str = Input.next();
        try{
             Byte.parseByte(Str);
             System.out.println("byte");
             return;
           }
        catch( NumberFormatException NFE)
        {
            try{
                Short.parseShort(Str);
                System.out.println("short");
                return;
               }
               catch( NumberFormatException NFE1)
               {
                 try{
                     Integer.parseInt(Str);
                     System.out.println("Integer");
                     return;
                    }
                 catch( NumberFormatException NFE2)
                   {
                     try{
                         Long.parseLong(Str);
                         System.out.println("long");
                         return;
                        }
                       catch( NumberFormatException NFE3)
                       {
                         System.out.println("BigInteger");
                       }
                   }
               }
        }

    }
}

public class TipeData4
{
    public static void main(String[]args)
    {
        java.util.Scanner reader = new java.util.Scanner(System.in);
        String baca = reader.next();
        long result = 0;
        try
        {
            result = Long.parseLong(baca);
            if(result<Integer.MIN_VALUE||result>Integer.MAX_VALUE)
                System.out.println("long");
            else if(result<Short.MIN_VALUE||result>Short.MAX_VALUE)
                System.out.println("int");
            else if(result<Long.MIN_VALUE||result>Long.MAX_VALUE)
                System.out.println("short");
            else
                System.out.println("byte");
        }
        catch(NumberFormatException e)
        {
            System.out.println("BigInteger");
        }
    }
}

import java.math.BigInteger;
import java.util.Scanner;

public class JavaApplication9 {

    public static void main(String[] args) {
        // TODO code application logic here
        Scanner sc = new Scanner (System.in);
        try {
            String s = sc.next();
            BigInteger b = new BigInteger(s);
            long l = Integer.parseInt(s);
            int i = Integer.parseInt(s);
            if ((i<=127) && (i>=-128)) {
                System.out.println("byte");
            }
            else
                System.out.println("short");
        }catch(Exception e){
            System.out.println("BigInteger");
        }

    }

}

        import java.util.Scanner;
public class Main {

    public static void main(String[] args) {

        Scanner  sc= new Scanner(System.in);
        String s = sc.nextLine();
        if(s.length()<=3)System.out.print("byte");
        else if(s.length()<=5)System.out.print("short");
        else if(s.length()<=10)System.out.print("int");
        else if(s.length()<=19)System.out.print("long");
        else System.out.print("BigInteger");

    }

}

import com.sun.org.apache.bcel.internal.Constants;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Scanner;
import java.util.StringTokenizer;

public class Hasan0504 {

    public static void main(String[] args) throws IOException {
        //  BufferedReader buffer = new BufferedReader(new InputStreamReader(System.in));

        Scanner input = new Scanner(System.in);
String a=input.next();

  if(a.length()>19)
            System.out.println("BigInteger");
 else

 {
 if(a.length()>=10){
     System.out.println("long");
 }
 else
 if(Integer.parseInt(a)>=-127 && Integer.parseInt(a)<=127)
            System.out.println("byte");
     else
     if(Integer.parseInt(a)>=-32768 && Integer.parseInt(a)<=32767)
            System.out.println("short");
 else
         if(Integer.parseInt(a)>=-2147483648 && Integer.parseInt(a)<= 2147483647)
              System.out.println("int");

   }  }}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import org.omg.CORBA.DynAny;

public class APetyaAndJava {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        try {
            BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

            String str = reader.readLine().trim();

            if (str.length() <= 19 || (str.length() == 20 && str.charAt(0) == '-')) {
                long x = Long.parseLong(str);
                if (x >= -128 && x <= 127) {
                    System.out.println("byte");
                } else if (x >= -32768 && x <= 32768) {
                    System.out.println("short");
                } else if (x >= -2147483648 && x <= 2147483647) {
                    System.out.println("int");
                } else {
                    System.out.println("long");
                }
            } else {
                System.out.println("BigInteger");
            }
            reader.close();
        } catch (Exception e) {
        }
    }
}

import static java.lang.System.in;
import java.util.Scanner;

public class A66 {
    public static void main(String[]args){
        Scanner in = new Scanner(System.in);
        try{long x = in.nextLong();

            if(x<=127)System.out.println("byte");
            else if(x<=32767) System.out.println("short");
            else if (x<=2147483647) System.out.println("int");
            else System.out.println("long");
                }
        catch(Exception e){ System.out.println("Biginteger");
    }

}
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.math.BigInteger;

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

      BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
      String line = br.readLine().trim();
      long  num  ;
      if (line.length()<= 19)
      {
       num = Long.parseLong(line);

      if (num >= -128  && num <= 127)
          System.out.println ("byte");
      else
           if (num >= -32768   &&  num <= 32767 )
          System.out.println ("short");
           else
           if (num >= -2147483648 &&  num <= 2147483647)

          System.out.println ("int");
      else
               if ( num <=9223372036854775807l )
           System.out.println ("long");

      }
      else

         System.out.println ("Biginteger");

}

      catch (Exception e){}

  }

}

import com.sun.org.apache.bcel.internal.Constants;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Scanner;
import java.util.StringTokenizer;

public class Hasan0504 {

    public static void main(String[] args) throws IOException {
        //  BufferedReader buffer = new BufferedReader(new InputStreamReader(System.in));

        Scanner input = new Scanner(System.in);
String a=input.next();

try{
  if(a.length()>19)
            System.out.println("BigInteger");
 else

 {
 if(a.length()>10){
     System.out.println("long");
 }

 else
 if(Integer.parseInt(a)>=-127 && Integer.parseInt(a)<=127)
            System.out.println("byte");
     else
     if(Integer.parseInt(a)>=-32768 && Integer.parseInt(a)<=32767)
            System.out.println("short");
 else
         if(Integer.parseInt(a)>=-2147483648 && Integer.parseInt(a)<= 2147483647)
              System.out.println("int");

  }  }catch(Exception v){System.out.println("int");}}}

import java.io.*;
import java.math.BigInteger;
import java.util.*;
public class Main {

	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		//PrintWriter out = new PrintWriter(System.out);
		String s = br.readLine();
		if(s.length()<=3 && Integer.parseInt(s)<=127)
			System.out.println("byte");
		else if(s.length()<=5 &&Integer.parseInt(s)<=32767)
			System.out.println("short");
		else if(s.length()<=10 &&Long.parseLong(s)<=2147483647)
			System.out.println("int");
		else if(s.length()<=19 &&new BigInteger(s).compareTo(new BigInteger(String.valueOf(2147483647)))<0)
			System.out.println("long");
		else
			System.out.println("BigInteger");
		//out.flush();
		//out.close();
		// end of main
	}

}

import java.math.BigInteger;
import java.util.Scanner;

public class JavaApplication9 {

    public static void main(String[] args) {
        // TODO code application logic here
        Scanner sc = new Scanner (System.in);
        try {
            String s = sc.next();
            BigInteger b = new BigInteger(s);
            long l = Integer.parseInt(s);
            int i = Integer.parseInt(s);
            int y = -32768;
            if ((i<=127) && (i>=-128)) {
                System.out.println("byte");
            }
            else if (i<=32767 && i>=y){
                System.out.println("short");
            }
            else
                System.out.println("int");
        }catch(Exception e){
            System.out.println("BigInteger");
        }

    }

}

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

import java.math.BigInteger;
import java.util.Scanner;

/**
 *
 * @author ahmed
 */
public class Acm1 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
      Scanner sc=new Scanner(System.in);
       String  number;

    number=sc.next();
    BigInteger bigInteger2 = new BigInteger (number);
    BigInteger bigInteger3 = new BigInteger ("-9223372036854775808");
    BigInteger bigInteger4 = new BigInteger ("9223372036854775807");

        int compareTo = bigInteger2.compareTo(bigInteger3);
        int compareTo2 = bigInteger2.compareTo(bigInteger4);

      if(bigInteger2.longValue()>=-128&&bigInteger2.longValue()<=127)
     System.out.println("byte");

      else  if(bigInteger2.longValue()>=-32768&&bigInteger2.longValue()<=32767)
       System.out.println("short");

      else  if(bigInteger2.longValue()>=-2147483648 &&bigInteger2.longValue()<=2147483647)
      System.out.println("int");

     else  if(compareTo==1&&compareTo2==-1)
      System.out.println("long");

     else
        System.out.println("BigInteger");

    }
}