#include <bits/stdc++.h>
using namespace std;
int GCD(int a, int b) { return a == 0 ? b : GCD(b % a, a); }
string ntoa(int b) {
  string a = "";
  while (b) {
    a += (b % 10 + '0');
    b /= 10;
  }
  reverse(a.begin(), a.end());
  return a;
}
struct myitem {
  int h;
  int w;
  myitem(int a, int b) {
    h = a;
    w = b;
    if (h > w) {
      int t = h;
      h = w;
      w = t;
    }
  }
};
bool mycompare(myitem a, myitem b) {
  if (a.h == b.h) return a.w < b.w;
  return a.h < b.h;
}
int findrep(int a, int *representative) {
  if (representative[a] != a) {
    return representative[a] = findrep(representative[a], representative);
  } else {
    return a;
  }
}
void unionfind(int x, int y, int *representative) {
  int xp, yp;
  xp = findrep(x, representative);
  yp = findrep(y, representative);
  representative[yp] = xp;
}
class Graph {
  int V;
  list<int> *adj;
  bool isCyclicUtil(int v, bool visited[], bool *rs);

 public:
  Graph(int V);
  void addEdge(int v, int w);
  bool isCyclic();
};
Graph::Graph(int V) {
  this->V = V;
  adj = new list<int>[V];
}
void Graph::addEdge(int v, int w) { adj[v].push_back(w); }
bool Graph::isCyclicUtil(int v, bool visited[], bool *recStack) {
  if (visited[v] == false) {
    visited[v] = true;
    recStack[v] = true;
    list<int>::iterator i;
    for (i = adj[v].begin(); i != adj[v].end(); ++i) {
      if (!visited[*i] && isCyclicUtil(*i, visited, recStack))
        return true;
      else if (recStack[*i])
        return true;
    }
  }
  recStack[v] = false;
  return false;
}
bool Graph::isCyclic() {
  bool *visited = new bool[V];
  bool *recStack = new bool[V];
  for (int i = 0; i < V; i++) {
    visited[i] = false;
    recStack[i] = false;
  }
  for (int i = 0; i < V; i++)
    if (isCyclicUtil(i, visited, recStack)) return true;
  return false;
}
int setbit(int N, int pos) { return N = N | (1 << pos); }
int resetbit(int N, int pos) { return N = N & (~(1 << pos)); }
int checkbit(int N, int pos) { return N & (1 << pos); }
int countsets(int N) {
  int a = 0;
  for (int i = 1; i <= N; i <<= 1) {
    if (N & i) a++;
  }
  return a;
}
int main() {
  long long int n = 1;
  int s;
  long long int total = 0;
  scanf("%d", &s);
  for (int i = 1; i <= s; ++i) {
    n *= 2;
    total += n;
  }
  cout << total << "\n";
  return 0;
}

### Prompt

Please create a solution in CPP to the following problem:

The numbers of all offices in the new building of the Tax Office of IT City will have lucky numbers.

Lucky number is a number that consists of digits 7 and 8 only. Find the maximum number of offices in the new building of the Tax Office given that a door-plate can hold a number not longer than n digits.

Input

The only line of input contains one integer n (1 ≤ n ≤ 55) — the maximum length of a number that a door-plate can hold.

Output

Output one integer — the maximum number of offices, than can have unique lucky numbers not longer than n digits.

Examples

Input

2


Output

6

### Response

```cpp
#include <bits/stdc++.h>
using namespace std;
int GCD(int a, int b) { return a == 0 ? b : GCD(b % a, a); }
string ntoa(int b) {
  string a = "";
  while (b) {
    a += (b % 10 + '0');
    b /= 10;
  }
  reverse(a.begin(), a.end());
  return a;
}
struct myitem {
  int h;
  int w;
  myitem(int a, int b) {
    h = a;
    w = b;
    if (h > w) {
      int t = h;
      h = w;
      w = t;
    }
  }
};
bool mycompare(myitem a, myitem b) {
  if (a.h == b.h) return a.w < b.w;
  return a.h < b.h;
}
int findrep(int a, int *representative) {
  if (representative[a] != a) {
    return representative[a] = findrep(representative[a], representative);
  } else {
    return a;
  }
}
void unionfind(int x, int y, int *representative) {
  int xp, yp;
  xp = findrep(x, representative);
  yp = findrep(y, representative);
  representative[yp] = xp;
}
class Graph {
  int V;
  list<int> *adj;
  bool isCyclicUtil(int v, bool visited[], bool *rs);

 public:
  Graph(int V);
  void addEdge(int v, int w);
  bool isCyclic();
};
Graph::Graph(int V) {
  this->V = V;
  adj = new list<int>[V];
}
void Graph::addEdge(int v, int w) { adj[v].push_back(w); }
bool Graph::isCyclicUtil(int v, bool visited[], bool *recStack) {
  if (visited[v] == false) {
    visited[v] = true;
    recStack[v] = true;
    list<int>::iterator i;
    for (i = adj[v].begin(); i != adj[v].end(); ++i) {
      if (!visited[*i] && isCyclicUtil(*i, visited, recStack))
        return true;
      else if (recStack[*i])
        return true;
    }
  }
  recStack[v] = false;
  return false;
}
bool Graph::isCyclic() {
  bool *visited = new bool[V];
  bool *recStack = new bool[V];
  for (int i = 0; i < V; i++) {
    visited[i] = false;
    recStack[i] = false;
  }
  for (int i = 0; i < V; i++)
    if (isCyclicUtil(i, visited, recStack)) return true;
  return false;
}
int setbit(int N, int pos) { return N = N | (1 << pos); }
int resetbit(int N, int pos) { return N = N & (~(1 << pos)); }
int checkbit(int N, int pos) { return N & (1 << pos); }
int countsets(int N) {
  int a = 0;
  for (int i = 1; i <= N; i <<= 1) {
    if (N & i) a++;
  }
  return a;
}
int main() {
  long long int n = 1;
  int s;
  long long int total = 0;
  scanf("%d", &s);
  for (int i = 1; i <= s; ++i) {
    n *= 2;
    total += n;
  }
  cout << total << "\n";
  return 0;
}

```