Little Petya has recently started attending a programming club. Naturally he is facing the problem of choosing a programming language. After long considerations he realized that Java is the best choice. The main argument in favor of choosing Java was that it has a very large integer data type, called BigInteger.But having attended several classes of the club, Petya realized that not all tasks require using the BigInteger type. It turned out that in some tasks it is much easier to use small data types. That's why a question arises: "Which integer type to use if one wants to store a positive integer n?"Petya knows only 5 integer types:1) byte occupies 1 byte and allows you to store numbers from  - 128 to 1272) short occupies 2 bytes and allows you to store numbers from  - 32768 to 327673) int occupies 4 bytes and allows you to store numbers from  - 2147483648 to 21474836474) long occupies 8 bytes and allows you to store numbers from  - 9223372036854775808 to 92233720368547758075) BigInteger can store any integer number, but at that it is not a primitive type, and operations with it are much slower.For all the types given above the boundary values are included in the value range.From this list, Petya wants to choose the smallest type that can store a positive integer n. Since BigInteger works much slower, Peter regards it last. Help him.

The first line contains a positive number n. It consists of no more than 100 digits and doesn't contain any leading zeros. The number n can't be represented as an empty string. Please, do not use %lld specificator to read or write 64-bit integers in C++. It is preffered to use cout (also you may use %I64d).

Print the first type from the list "byte, short, int, long, BigInteger", that can store the natural number n, in accordance with the data given above.

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.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;

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

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.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.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.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.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.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" );

    }

}

/* 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.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.*;

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

/*
 * 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.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.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.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;

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

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.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.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.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.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 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");
    }
}

             // 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.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.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");
        }

    }

}

/* 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.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.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.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.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.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.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.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.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.*;

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

//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");
  }
}

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.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.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.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.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");
	}
}

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.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.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.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.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 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 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.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.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.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.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.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");
	}

}

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

    }
}

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.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.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");
        }
    }
}

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

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.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.*;

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.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");
    }
}

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.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 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");
  }
}

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

/* 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.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.*;
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.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.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");

    }
}