description: It is the easy version of the problem. The difference is that in this version, there are no nodes with already chosen colors.
  
  Theofanis is starving, and he wants to eat his favorite food, sheftalia. However, he should first finish his homework. Can you help him with this problem?
  
  You have a perfect binary tree of 2^k - 1 nodes — a binary tree where all vertices i from 1 to 2^{k - 1} - 1 have exactly two children: vertices 2i and 2i + 1. Vertices from 2^{k - 1} to 2^k - 1 don't have any children. You want to color its vertices with the 6 Rubik's cube colors (White, Green, Red, Blue, Orange and Yellow).
  
  Let's call a coloring good when all edges connect nodes with colors that are neighboring sides in the Rubik's cube.
  
  <image>| <image>  
  ---|---  
  A picture of Rubik's cube and its 2D map.
  
  More formally: 
  
    * a white node can not be neighboring with white and yellow nodes; 
    * a yellow node can not be neighboring with white and yellow nodes; 
    * a green node can not be neighboring with green and blue nodes; 
    * a blue node can not be neighboring with green and blue nodes; 
    * a red node can not be neighboring with red and orange nodes; 
    * an orange node can not be neighboring with red and orange nodes; 
  
  
  
  You want to calculate the number of the good colorings of the binary tree. Two colorings are considered different if at least one node is colored with a different color.
  
  The answer may be too large, so output the answer modulo 10^9+7.
  
  Input
  
  The first and only line contains the integers k (1 ≤ k ≤ 60) — the number of levels in the perfect binary tree you need to color.
  
  Output
  
  Print one integer — the number of the different colorings modulo 10^9+7.
  
  Examples
  
  Input
  
  
  3
  
  
  Output
  
  
  24576
  
  
  Input
  
  
  14
  
  
  Output
  
  
  934234
  
  Note
  
  In the picture below, you can see one of the correct colorings of the first example.
  
  <image>
solution: import java.util.*;
  
  
  import java.io.*;
  import java.awt.Point;
  
  public class Main{
  
      static long mod = (long) (Math.pow(10, 9)+7);
  	static final int dx[] = { -1, 0, 1, 0 }, dy[] = { 0, -1, 0, 1 };
  	static final int[] dx8 = { -1, -1, -1, 0, 0, 1, 1, 1 }, dy8 = { -1, 0, 1, -1, 1, -1, 0, 1 };
  	static final int[] dx9 = { -1, -1, -1, 0, 0, 0, 1, 1, 1 }, dy9 = { -1, 0, 1, -1, 0, 1, -1, 0, 1 };
  	static final int inf = Integer.MAX_VALUE / 2;
  	static final long infL = Long.MAX_VALUE / 3;
  	static final double infD = Double.MAX_VALUE / 3;
  	static final double eps = 1e-10;
  	static final double pi = Math.PI;
      static List<Integer> primeNumbers = new ArrayList<>();
  
      public static long power(long x, long y)
      {
          long res = 1L;     // Initialize result
          while (y > 0)
          {
              // If y is odd, multiply x with result
              if ((y & 1) != 0){
                  x %= mod;
                  res %= mod;
                  res = (res * x)%mod;
              }
              // y must be even now
              y = y >> 1; // y = y/2
              x%= mod;
              x = (x * x)%mod;  // Change x to x^2
          }
          // 550193677
          return res%mod;
      }
  
      public static long power2(long x, long y)
      {
          long res = 1L;     // Initialize result
          while (y > 0)
          {
              // If y is odd, multiply x with result
              if ((y & 1) != 0){
                  res = (res * x);
              }
              // y must be even now
              y = y >> 1; // y = y/
              x = (x * x);
          }
          // 550193677
          return res;
      }
      public static void main(String[] args) {
          MyScanner sc = new MyScanner();
          out = new PrintWriter(new BufferedOutputStream(System.out));
  
          long inp = sc.nextLong();
          long number = (power2(2L,inp) - 2L);
          
          long n = power(4L,number)%mod;
          n = (n*6L)%mod;
      
          out.println(n);
          out.close();
      }
  
      //-------------------------------------------------------------------
      //-------------------------------------------------------------------
      //-------------------------------------------------------------------
      //-------------------------------------------------------------------
      //-------------------------------------------------------------------
  
      public static class segmentTree{
  
          public long[] arr;
          public long[] tree;
          public long[] lazy;
  
          segmentTree(long[] array){
              int n = array.length;
              arr = new long[n];
              for(int i= 0; i < n; i++) arr[i] = array[i];
              tree = new long[4*n + 1];
              lazy = new long[4*n + 1];
          }
  
          public  void build(int[]arr, int s, int e, int[] tree, int index){
  
              if(s == e){
                  tree[index] = arr[s];
                  return;
              }
      
              //otherwise divide in two parts and fill both sides simply
              int mid = (s+e)/2;
              build(arr, s, mid, tree, 2*index);
              build(arr, mid+1, e, tree, 2*index+1);
      
              //who will build the current position dude
              tree[index] = Math.min(tree[2*index], tree[2*index+1]);
          }
      
          public  int query(int sr, int er, int sc, int ec, int index, int[] tree){
              
              if(lazy[index] != 0){
                  tree[index] += lazy[index];
      
                  if(sc != ec){
                      lazy[2*index+1] += lazy[index];
                      lazy[2*index] += lazy[index];
                  }
      
                  lazy[index] = 0;
              }
              
              //no overlap
              if(sr > ec || sc > er) return Integer.MAX_VALUE;
      
              //found the index baby
              if(sr <= sc && ec <= er) return tree[index];
      
              //finding the index on both sides hehehehhe
              int mid = (sc + ec)/2;
              int left = query(sr, er, sc, mid, 2*index, tree);
              int right = query(sr, er, mid+1, ec, 2*index + 1, tree);
      
              return Integer.min(left, right);
          }
      
          //now we will do point update implementation
          //it should be simple then we expected for sure
          public  void update(int index, int indexr, int increment, int[] tree, int s, int e){
      
              if(lazy[index] != 0){
                  tree[index] += lazy[index];
      
                  if(s != e){
                      lazy[2*index+1] = lazy[index];
                      lazy[2*index] = lazy[index];
                  }
                  
                  lazy[index] = 0;
              }
      
              //no overlap
              if(indexr < s || indexr > e) return;
      
              //found the required index
              if(s == e){
                  tree[index] += increment;
                  return;
              } 
      
              //search for the index on both sides
              int mid = (s+e)/2;
              update(2*index, indexr, increment, tree, s, mid);
              update(2*index+1, indexr, increment, tree, mid+1, e);
      
              //now update the current range simply
              tree[index] = Math.min(tree[2*index+1], tree[2*index]);
          }
      
          public  void rangeUpdate(int[] tree , int index, int s, int e, int sr, int er, int increment){
      
              //if not at all in the same range
              if(e < sr || er < s) return;
      
              //complete then also move forward
              if(s == e){
                  tree[index] += increment;
                  return;
              }
      
              //otherwise move in both subparts
              int mid = (s+e)/2;
              rangeUpdate(tree, 2*index, s, mid, sr, er, increment);
              rangeUpdate(tree, 2*index + 1, mid+1, e, sr, er, increment);
      
              //update current range too na
              //i always forget this step for some reasons hehehe, idiot
              tree[index] = Math.min(tree[2*index], tree[2*index + 1]);
          }
          
          public  void rangeUpdateLazy(int[] tree, int index, int s, int e, int sr, int er, int increment){
              
              //update lazy values
              //resolve lazy value before going down
              if(lazy[index] != 0){
                  tree[index] += lazy[index];
      
                  if(s != e){
                      lazy[2*index+1] += lazy[index];
                      lazy[2*index] += lazy[index];
                  }
      
                  lazy[index] = 0;
              }
      
              //no overlap case
              if(sr > e || s > er) return;
      
              //complete overlap
              if(sr <= s && er >= e){
                  tree[index] += increment;
      
                  if(s != e){
                      lazy[2*index+1] += increment;
                      lazy[2*index] += increment;
                  }
                  return;
              }
      
              //otherwise go on both left and right side and do your shit
              int mid = (s + e)/2;
              rangeUpdateLazy(tree, 2*index, s, mid, sr, er, increment);
              rangeUpdateLazy(tree, 2*index + 1, mid+1, e, sr, er, increment);
      
              tree[index] = Math.min(tree[2*index+1], tree[2*index]);
              return;
      
          }
      
      }
  
      //prime sieve
      public static void primeSieve(int n){
          BitSet bitset = new BitSet(n+1);
          for(long i = 0; i < n ; i++){
              if (i == 0 || i == 1) {
                  bitset.set((int) i);
                  continue;
              }
              if(bitset.get((int) i)) continue;
              primeNumbers.add((int)i);
              for(long j = i; j <= n ; j+= i)
                  bitset.set((int)j);
          }
      }
  
      //number of divisors
      public static int countDivisors(long number){
          if(number == 1) return 1;
          List<Integer> primeFactors = new ArrayList<>();
          int index = 0;
          long curr = primeNumbers.get(index);
          while(curr * curr <= number){
              while(number % curr == 0){
                  number = number/curr;
                  primeFactors.add((int) curr);
              }    
              index++;
              curr = primeNumbers.get(index);
          }
  
          if(number != 1) primeFactors.add((int) number);
          int current = primeFactors.get(0);
          int totalDivisors = 1;
          int currentCount = 2;
          for (int i = 1; i < primeFactors.size(); i++) {
              if (primeFactors.get(i) == current) {
                  currentCount++;
              } else {
                  totalDivisors *= currentCount;
                  currentCount = 2;
                  current = primeFactors.get(i);
              }
          }
          totalDivisors *= currentCount;
          return totalDivisors;
      }
  
      //now adding next permutation function to java hehe
      public static boolean next_permutation(int[] p) {
          for (int a = p.length - 2; a >= 0; --a)
            if (p[a] < p[a + 1])
              for (int b = p.length - 1;; --b)
                if (p[b] > p[a]) {
                  int t = p[a];
                  p[a] = p[b];
                  p[b] = t;
                  for (++a, b = p.length - 1; a < b; ++a, --b) {
                    t = p[a];
                    p[a] = p[b];
                    p[b] = t;
                  }
                  return true;
                }
          return false;
      }
  
      //finding the value of NCR in O(RlogN) time and O(1) space
      public static long getNcR(int n, int r)
      {
          long p = 1, k = 1;
          if (n - r < r) r = n - r;
  
          if (r != 0) {
              while (r > 0) {
                  p *= n;
                  k *= r;
                  long m = __gcd(p, k);
                  p /= m;
                  k /= m;
                  n--;
                  r--;
              }
          }
          else {
              p = 1;
          }
          return p;
      }
  
      public static void sort(long[] a) {
  		ArrayList<Long> l=new ArrayList<>();
  		for (long i:a) l.add(i);
  		Collections.sort(l);
  		for (int i=0; i<a.length; i++) a[i]=l.get(i);
  	}
   
      //for ncr calculator
      public static long __gcd(long n1, long n2)
      {
          long gcd = 1;
          for (int i = 1; i <= n1 && i <= n2; ++i) {
              // Checks if i is factor of both integers
              if (n1 % i == 0 && n2 % i == 0) {
                  gcd = i;
              }
          }
          return gcd;
      }
  
  
  
      //is vowel function 
      public static boolean isVowel(char c)
      {
          return (c=='a' || c=='A' || c=='e' || c=='E' || c=='i' || c=='I' || c=='o' || c=='O' ||     c=='u' || c=='U');
      }   
  
      //two add two big numbers with some mod 
      // public static int add(int a, int b) {
  	// 	a+=b;
  	// 	if (a>=mod) return a-mod;
  	// 	return a;
  	// }
  	
      //two sub two numbers
  	public static int sub(int a, int b) {
  		a-=b;
  		if (a<0) a+=mod;
  		else if (a>=mod) a-=mod;
  		return a;
  	}
   
      //to sort the array with better method
  	public static void sort(int[] a) {
  		ArrayList<Integer> l=new ArrayList<>();
  		for (int i:a) l.add(i);
  		Collections.sort(l);
  		for (int i=0; i<a.length; i++) a[i]=l.get(i);
  	}
  	
      //for calculating binomialCoeff
      public static int binomialCoeff(int n, int k)
      {
          int C[] = new int[k + 1];
          // nC0 is 1
          C[0] = 1;
          for (int i = 1; i <= n; i++) {
              // Compute next row of pascal
              // triangle using the previous row
              for (int j = Math.min(i, k); j > 0; j--)
                  C[j] = C[j] + C[j - 1];
          }
          return C[k];
      }
  
      //Pair with int int 
      public static class Pair{
  
          public int a;
          public int b;
  
          Pair(int a , int b){
              this.a = a;
              this.b = b;
          }
  
          @Override
          public String toString(){
              return a + " -> " + b; 
          }
      }
  
      //Triplet with int int int
      public static class Triplet{
  
          public int a;
          public int b;
          public int c;
  
          Triplet(int a , int b, int c){
              this.a = a;
              this.b = b;
              this.c = c;
          }
  
          @Override
          public String toString(){
              return a + " -> " + b; 
          }
      }
  
      //Shortcut function
      public static long lcm(long a , long b){
          return a * (b/gcd(a,b));
      }
  
      //let's make one for calculating lcm basically
      public static int lcm(int a , int b){
          return (a * b)/gcd(a,b);
      }
  
      //int version for gcd
      public static int gcd(int a, int b){
          if(b == 0)
              return a;
              
          return gcd(b , a%b);
      }
  
      //long version for gcd
      public static long gcd(long a, long b){
          if(b == 0)
              return a;
  
          return gcd(b , a%b);
      }
  
      //swapping two elements in an array
      public static void swap(int[] arr, int left , int right){
          int temp = arr[left];
          arr[left] = arr[right];
          arr[right] = temp;
      }
  
      //
       //for char array
       public static void swap(char[] arr, int left , int right){
          char temp = arr[left];
          arr[left] = arr[right];
          arr[right] = temp;
      }
  
      //reversing an array
      public static void reverse(int[] arr){
          int left = 0;
          int right = arr.length-1;
  
          while(left <= right){
              swap(arr, left,right);
              left++;
              right--;
          }
      }
  
       
      //-----------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;
          }
  
      }
     //--------------------------------------------------------
  }