#include <bits/stdc++.h>
using namespace std;
vector<int> p, d, lvl, dfs_transversal, dfs_lvl, dfs_first, dualp, pot2;
vector<vector<int> > adj, sparse_table;
stack<pair<int, int> > sk;
queue<int> qu;
int min_ind_query(int x, int y) {
  if (x == y) return dfs_transversal[x];
  int u = upper_bound(pot2.begin(), pot2.end(), y - x) - pot2.begin() - 1;
  if (lvl[sparse_table[u][x]] < lvl[sparse_table[u][y - pot2[u] + 1]]) {
    return sparse_table[u][x];
  } else {
    return sparse_table[u][y - pot2[u] + 1];
  }
}
int lca(int x, int y) {
  x = dfs_first[x], y = dfs_first[y];
  if (y < x) swap(x, y);
  return min_ind_query(x, y);
}
class paths_seg_tree {
 private:
  vector<pair<int, int> > _tree;
  vector<int> _data;
  int _n;
  inline int left(int x) { return (x << 1); }
  inline int right(int x) { return (x << 1) + 1; }
  pair<int, int> join_paths(pair<int, int> x, pair<int, int> y) {
    if (x.first == -1 || y.first == -1) return pair<int, int>(-1, -1);
    if (x.first == -2) return y;
    if (y.first == -2) return x;
    int px = lca(x.first, x.second), py = lca(y.first, y.second);
    bool vx = (px == x.first || px == x.second),
         vy = (py == y.first || py == y.second);
    if (vx && vy) {
      int xmax, ymax, xmin, ymin;
      if (lvl[x.first] < lvl[x.second]) {
        xmax = x.second;
        xmin = x.first;
      } else {
        xmax = x.first;
        xmin = x.second;
      }
      if (lvl[y.first] < lvl[y.second]) {
        ymax = y.second;
        ymin = y.first;
      } else {
        ymax = y.first;
        ymin = y.second;
      }
      int pmin = lca(xmin, ymin);
      if (pmin != xmin && pmin != ymin) {
        return pair<int, int>(xmax, ymax);
      } else if (pmin == xmin) {
      dobleCasoX:
        int paux = lca(xmax, ymin);
        if (paux == pmin)
          return pair<int, int>(xmax, ymax);
        else if (paux == xmax)
          return pair<int, int>(xmin, ymax);
        else if (paux == ymin) {
          int paux2 = lca(xmax, ymax);
          if (paux2 == xmax)
            return pair<int, int>(xmin, ymax);
          else if (paux2 == ymax)
            return pair<int, int>(xmin, xmax);
          else
            return pair<int, int>(-1, -1);
        } else
          return pair<int, int>(-1, -1);
      } else if (pmin == ymin) {
        swap(xmin, ymin);
        swap(xmax, ymax);
        goto dobleCasoX;
      }
    } else if (vx) {
    sencilloCasoX:
      int xmin, xmax;
      if (lvl[x.first] > lvl[x.second]) {
        xmin = x.second;
        xmax = x.first;
      } else {
        xmin = x.first;
        xmax = x.second;
      }
      if (lca(py, xmin) != py) return pair<int, int>(-1, -1);
      if (xmin == py) {
        int pfi = lca(y.first, xmax), pse = lca(y.second, xmax);
        if (pfi == y.first) return pair<int, int>(xmax, y.second);
        if (pfi == xmax) return pair<int, int>(y.first, y.second);
        if (pse == y.second) return pair<int, int>(y.first, xmax);
        if (pse == xmax) return pair<int, int>(y.first, y.second);
        return pair<int, int>(-1, -1);
      }
      int pfi = lca(xmin, y.first), pse = lca(xmin, y.second);
      if (pfi == y.first) return pair<int, int>(y.second, xmax);
      if (pse == y.second) return pair<int, int>(y.first, xmax);
      if (pfi == xmin) {
        int paux = lca(xmax, y.first);
        if (paux == xmax)
          return pair<int, int>(y.first, y.second);
        else if (paux == y.first)
          return pair<int, int>(xmax, y.second);
        else
          return pair<int, int>(-1, -1);
      }
      if (pse == xmin) {
        int paux = lca(xmax, y.second);
        if (paux == xmax)
          return pair<int, int>(y.first, y.second);
        else if (paux == y.second)
          return pair<int, int>(y.first, xmax);
        else
          return pair<int, int>(-1, -1);
      }
      return pair<int, int>(-1, -1);
    } else if (vy) {
      swap(x, y);
      swap(px, py);
      goto sencilloCasoX;
    } else if (px == py) {
      int p1 = lca(x.first, y.first), p2 = lca(x.second, y.second);
      if (p1 == x.first) {
        if (p2 == x.second)
          return pair<int, int>(y.first, y.second);
        else if (p2 == y.second)
          return pair<int, int>(y.first, x.second);
        else
          return pair<int, int>(-1, -1);
      } else if (p1 == y.first) {
        if (p2 == x.second)
          return pair<int, int>(x.first, y.second);
        else if (p2 == y.second)
          return pair<int, int>(x.first, x.second);
        else
          return pair<int, int>(-1, -1);
      } else {
        p1 = lca(x.first, y.second), p2 = lca(x.second, y.first);
        if (p1 == x.first) {
          if (p2 == x.second)
            return pair<int, int>(y.second, y.first);
          else if (p2 == y.first)
            return pair<int, int>(y.second, x.second);
          else
            return pair<int, int>(-1, -1);
        } else if (p1 == y.second) {
          if (p2 == x.second)
            return pair<int, int>(x.first, y.first);
          else if (p2 == y.first)
            return pair<int, int>(x.first, x.second);
          else
            return pair<int, int>(-1, -1);
        } else
          return pair<int, int>(-1, -1);
      }
    } else
      return pair<int, int>(-1, -1);
  }
  void build(int ind, int l, int r) {
    if (l == r) {
      _tree[ind] = pair<int, int>(_data[l], _data[r]);
      return;
    }
    build(left(ind), l, (l + r) / 2);
    build(right(ind), (l + r) / 2 + 1, r);
    _tree[ind] = join_paths(_tree[left(ind)], _tree[right(ind)]);
  }
  void update(int ind, int l, int r, int ind_1, int ind_2) {
    if ((l > ind_1 || r < ind_1) && (l > ind_2 || r < ind_2)) return;
    if (l == r) {
      _tree[ind] = pair<int, int>(_data[l], _data[r]);
      return;
    }
    update(left(ind), l, (l + r) / 2, ind_1, ind_2);
    update(right(ind), (l + r) / 2 + 1, r, ind_1, ind_2);
    _tree[ind] = join_paths(_tree[left(ind)], _tree[right(ind)]);
  }
  pair<int, int> query(int ind, int l, int r, int lquery, int rquery) {
    if (l > rquery || r < lquery) return pair<int, int>(-2, -2);
    if (lquery <= l && rquery >= r) return _tree[ind];
    pair<int, int> ul = query(left(ind), l, (l + r) / 2, lquery, rquery);
    pair<int, int> ur = query(right(ind), (l + r) / 2 + 1, r, lquery, rquery);
    return join_paths(ul, ur);
  }
  void recorrido(int ind, int l, int r) {
    if (l == r) {
      printf("%d %d: %d %d\n", l, r, _tree[ind].first, _tree[ind].second);
      return;
    }
    recorrido(left(ind), l, (l + r) / 2);
    recorrido(right(ind), (l + r) / 2 + 1, r);
    printf("%d %d: %d %d\n", l, r, _tree[ind].first, _tree[ind].second);
  }

 public:
  void build(vector<int> &data) {
    _data = data;
    _n = _data.size();
    _tree.assign(4 * _n, pair<int, int>(0, 0));
    build(1, 0, _n - 1);
  }
  void update(int ind1, int ind2, int newdata1, int newdata2) {
    _data[ind1] = newdata1;
    _data[ind2] = newdata2;
    update(1, 0, _n - 1, ind1, ind2);
  }
  bool query(int r) { return query(1, 0, _n - 1, 0, r).first != -1; }
  void recorrido() { recorrido(1, 0, _n - 1); }
} st;
int main() {
  if (fopen("input.txt", "r")) freopen("input.txt", "r", stdin);
  pot2.push_back(1);
  for (int i = 0; i < 20; i++) pot2.push_back(2 * pot2[i]);
  int n;
  scanf("%d ", &n);
  p.assign(n + 1, 0);
  for (int i = 1; i < n + 1; i++) scanf("%d ", &p[i]);
  d.assign(n + 1, 0);
  for (int i = 2; i < n + 1; i++) scanf("%d ", &d[i]);
  adj.assign(n + 1, vector<int>());
  for (int i = 2; i < n + 1; i++) adj[d[i]].push_back(i);
  lvl.assign(n + 1, -1);
  qu.push(1);
  lvl[1] = 0;
  while (!qu.empty()) {
    int u = qu.front();
    qu.pop();
    for (int i = 0; i < adj[u].size(); i++)
      if (adj[u][i] != d[u]) {
        lvl[adj[u][i]] = lvl[u] + 1;
        qu.push(adj[u][i]);
      }
  }
  dfs_first.assign(n + 1, -1);
  sk.push(pair<int, int>(1, 0));
  while (!sk.empty()) {
    pair<int, int> u = sk.top();
    sk.pop();
    if (dfs_first[u.first] == -1) dfs_first[u.first] = dfs_transversal.size();
    dfs_transversal.push_back(u.first);
    dfs_lvl.push_back(lvl[u.first]);
    if (u.second == adj[u.first].size()) continue;
    sk.push(pair<int, int>(u.first, u.second + 1));
    sk.push(pair<int, int>(adj[u.first][u.second], 0));
  }
  int tamrecorrido = dfs_lvl.size();
  sparse_table.assign(20, vector<int>(tamrecorrido, 0));
  for (int i = 0; i < tamrecorrido; i++)
    sparse_table[0][i] = dfs_transversal[i];
  for (int i = 1; i < 20; i++) {
    int salto = (1 << (i - 1));
    if (salto >= tamrecorrido) break;
    for (int j = 0; j < tamrecorrido - salto; j++)
      if (lvl[sparse_table[i - 1][j]] < lvl[sparse_table[i - 1][j + salto]]) {
        sparse_table[i][j] = sparse_table[i - 1][j];
      } else {
        sparse_table[i][j] = sparse_table[i - 1][j + salto];
      }
  }
  dualp.assign(n, 0);
  for (int i = 1; i < n + 1; i++) dualp[p[i]] = i;
  st.build(dualp);
  int q;
  scanf("%d ", &q);
  while (q--) {
    int t;
    scanf("%d ", &t);
    if (t == 1) {
      int x, y, px, py;
      scanf("%d %d ", &x, &y);
      px = p[x];
      py = p[y];
      st.update(px, py, y, x);
      p[x] = py;
      p[y] = px;
    } else {
      int lo = 0, hi = n;
      while (lo + 1 < hi) {
        int mi = (lo + hi) / 2;
        if (st.query(mi))
          lo = mi;
        else
          hi = mi;
      }
      printf("%d\n", hi);
    }
  }
  return 0;
}

### Prompt

Please create a solution in Cpp to the following problem:

Once Grisha found a tree (connected graph without cycles) with a root in node 1.

But this tree was not just a tree. A permutation p of integers from 0 to n - 1 is written in nodes, a number p_i is written in node i.

As Grisha likes to invent some strange and interesting problems for himself, but not always can solve them, you need to help him deal with two types of queries on this tree.

Let's define a function MEX(S), where S is a set of non-negative integers, as a smallest non-negative integer that is not included in this set.

Let l be a simple path in this tree. So let's define indices of nodes which lie on l as u_1, u_2, …, u_k. 

Define V(l) as a set {p_{u_1}, p_{u_2}, … , p_{u_k}}. 

Then queries are: 

  1. For two nodes i and j, swap p_i and p_j. 
  2. Find the maximum value of MEX(V(l)) in all possible l. 

Input

The first line contains a single integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of nodes of a tree.

The second line contains n integers — p_1, p_2, …, p_n (0≤ p_i < n) — the permutation p, it's guaranteed that all numbers are different .

The third line contains n - 1 integers — d_2, d_3, …, d_n (1 ≤ d_i < i), where d_i is a direct ancestor of node i in a tree.

The fourth line contains a single integer q (1 ≤ q ≤ 2 ⋅ 10^5) — the number of queries.

The following q lines contain the description of queries:

At the beginning of each of next q lines, there is a single integer t (1 or 2) — the type of a query: 

  1. If t = 1, the line also contains two integers i and j (1 ≤ i, j ≤ n) — the indices of nodes, where values of the permutation should be swapped. 
  2. If t = 2, you need to find the maximum value of MEX(V(l)) in all possible l. 

Output

For each type 2 query print a single integer — the answer for this query.

Examples

Input


6
2 5 0 3 1 4
1 1 3 3 3
3
2
1 6 3
2


Output


3
2


Input


6
5 2 1 4 3 0
1 1 1 3 3
9
2
1 5 3
2
1 6 1
2
1 4 2
2
1 1 6
2


Output


3
2
4
4
2

Note

Number written in brackets is a permutation value of a node. 

<image> In the first example, for the first query, optimal path is a path from node 1 to node 5. For it, set of values is \{0, 1, 2\} and MEX is 3.  <image> For the third query, optimal path is a path from node 5 to node 6. For it, set of values is \{0, 1, 4\} and MEX is 2.  <image> In the second example, for the first query, optimal path is a path from node 2 to node 6. For it, set of values is \{0, 1, 2, 5\} and MEX is 3.  <image> For the third query, optimal path is a path from node 5 to node 6. For it, set of values is \{0, 1, 3\} and MEX is 2.  <image> For the fifth query, optimal path is a path from node 5 to node 2. For it, set of values is \{0, 1, 2, 3\} and MEX is 4.  <image> For the seventh query, optimal path is a path from node 5 to node 4. For it, set of values is \{0, 1, 2, 3\} and MEX is 4.  <image> For the ninth query, optimal path is a path from node 6 to node 5. For it, set of values is \{0, 1, 3\} and MEX is 2. 

### Response

```cpp
#include <bits/stdc++.h>
using namespace std;
vector<int> p, d, lvl, dfs_transversal, dfs_lvl, dfs_first, dualp, pot2;
vector<vector<int> > adj, sparse_table;
stack<pair<int, int> > sk;
queue<int> qu;
int min_ind_query(int x, int y) {
  if (x == y) return dfs_transversal[x];
  int u = upper_bound(pot2.begin(), pot2.end(), y - x) - pot2.begin() - 1;
  if (lvl[sparse_table[u][x]] < lvl[sparse_table[u][y - pot2[u] + 1]]) {
    return sparse_table[u][x];
  } else {
    return sparse_table[u][y - pot2[u] + 1];
  }
}
int lca(int x, int y) {
  x = dfs_first[x], y = dfs_first[y];
  if (y < x) swap(x, y);
  return min_ind_query(x, y);
}
class paths_seg_tree {
 private:
  vector<pair<int, int> > _tree;
  vector<int> _data;
  int _n;
  inline int left(int x) { return (x << 1); }
  inline int right(int x) { return (x << 1) + 1; }
  pair<int, int> join_paths(pair<int, int> x, pair<int, int> y) {
    if (x.first == -1 || y.first == -1) return pair<int, int>(-1, -1);
    if (x.first == -2) return y;
    if (y.first == -2) return x;
    int px = lca(x.first, x.second), py = lca(y.first, y.second);
    bool vx = (px == x.first || px == x.second),
         vy = (py == y.first || py == y.second);
    if (vx && vy) {
      int xmax, ymax, xmin, ymin;
      if (lvl[x.first] < lvl[x.second]) {
        xmax = x.second;
        xmin = x.first;
      } else {
        xmax = x.first;
        xmin = x.second;
      }
      if (lvl[y.first] < lvl[y.second]) {
        ymax = y.second;
        ymin = y.first;
      } else {
        ymax = y.first;
        ymin = y.second;
      }
      int pmin = lca(xmin, ymin);
      if (pmin != xmin && pmin != ymin) {
        return pair<int, int>(xmax, ymax);
      } else if (pmin == xmin) {
      dobleCasoX:
        int paux = lca(xmax, ymin);
        if (paux == pmin)
          return pair<int, int>(xmax, ymax);
        else if (paux == xmax)
          return pair<int, int>(xmin, ymax);
        else if (paux == ymin) {
          int paux2 = lca(xmax, ymax);
          if (paux2 == xmax)
            return pair<int, int>(xmin, ymax);
          else if (paux2 == ymax)
            return pair<int, int>(xmin, xmax);
          else
            return pair<int, int>(-1, -1);
        } else
          return pair<int, int>(-1, -1);
      } else if (pmin == ymin) {
        swap(xmin, ymin);
        swap(xmax, ymax);
        goto dobleCasoX;
      }
    } else if (vx) {
    sencilloCasoX:
      int xmin, xmax;
      if (lvl[x.first] > lvl[x.second]) {
        xmin = x.second;
        xmax = x.first;
      } else {
        xmin = x.first;
        xmax = x.second;
      }
      if (lca(py, xmin) != py) return pair<int, int>(-1, -1);
      if (xmin == py) {
        int pfi = lca(y.first, xmax), pse = lca(y.second, xmax);
        if (pfi == y.first) return pair<int, int>(xmax, y.second);
        if (pfi == xmax) return pair<int, int>(y.first, y.second);
        if (pse == y.second) return pair<int, int>(y.first, xmax);
        if (pse == xmax) return pair<int, int>(y.first, y.second);
        return pair<int, int>(-1, -1);
      }
      int pfi = lca(xmin, y.first), pse = lca(xmin, y.second);
      if (pfi == y.first) return pair<int, int>(y.second, xmax);
      if (pse == y.second) return pair<int, int>(y.first, xmax);
      if (pfi == xmin) {
        int paux = lca(xmax, y.first);
        if (paux == xmax)
          return pair<int, int>(y.first, y.second);
        else if (paux == y.first)
          return pair<int, int>(xmax, y.second);
        else
          return pair<int, int>(-1, -1);
      }
      if (pse == xmin) {
        int paux = lca(xmax, y.second);
        if (paux == xmax)
          return pair<int, int>(y.first, y.second);
        else if (paux == y.second)
          return pair<int, int>(y.first, xmax);
        else
          return pair<int, int>(-1, -1);
      }
      return pair<int, int>(-1, -1);
    } else if (vy) {
      swap(x, y);
      swap(px, py);
      goto sencilloCasoX;
    } else if (px == py) {
      int p1 = lca(x.first, y.first), p2 = lca(x.second, y.second);
      if (p1 == x.first) {
        if (p2 == x.second)
          return pair<int, int>(y.first, y.second);
        else if (p2 == y.second)
          return pair<int, int>(y.first, x.second);
        else
          return pair<int, int>(-1, -1);
      } else if (p1 == y.first) {
        if (p2 == x.second)
          return pair<int, int>(x.first, y.second);
        else if (p2 == y.second)
          return pair<int, int>(x.first, x.second);
        else
          return pair<int, int>(-1, -1);
      } else {
        p1 = lca(x.first, y.second), p2 = lca(x.second, y.first);
        if (p1 == x.first) {
          if (p2 == x.second)
            return pair<int, int>(y.second, y.first);
          else if (p2 == y.first)
            return pair<int, int>(y.second, x.second);
          else
            return pair<int, int>(-1, -1);
        } else if (p1 == y.second) {
          if (p2 == x.second)
            return pair<int, int>(x.first, y.first);
          else if (p2 == y.first)
            return pair<int, int>(x.first, x.second);
          else
            return pair<int, int>(-1, -1);
        } else
          return pair<int, int>(-1, -1);
      }
    } else
      return pair<int, int>(-1, -1);
  }
  void build(int ind, int l, int r) {
    if (l == r) {
      _tree[ind] = pair<int, int>(_data[l], _data[r]);
      return;
    }
    build(left(ind), l, (l + r) / 2);
    build(right(ind), (l + r) / 2 + 1, r);
    _tree[ind] = join_paths(_tree[left(ind)], _tree[right(ind)]);
  }
  void update(int ind, int l, int r, int ind_1, int ind_2) {
    if ((l > ind_1 || r < ind_1) && (l > ind_2 || r < ind_2)) return;
    if (l == r) {
      _tree[ind] = pair<int, int>(_data[l], _data[r]);
      return;
    }
    update(left(ind), l, (l + r) / 2, ind_1, ind_2);
    update(right(ind), (l + r) / 2 + 1, r, ind_1, ind_2);
    _tree[ind] = join_paths(_tree[left(ind)], _tree[right(ind)]);
  }
  pair<int, int> query(int ind, int l, int r, int lquery, int rquery) {
    if (l > rquery || r < lquery) return pair<int, int>(-2, -2);
    if (lquery <= l && rquery >= r) return _tree[ind];
    pair<int, int> ul = query(left(ind), l, (l + r) / 2, lquery, rquery);
    pair<int, int> ur = query(right(ind), (l + r) / 2 + 1, r, lquery, rquery);
    return join_paths(ul, ur);
  }
  void recorrido(int ind, int l, int r) {
    if (l == r) {
      printf("%d %d: %d %d\n", l, r, _tree[ind].first, _tree[ind].second);
      return;
    }
    recorrido(left(ind), l, (l + r) / 2);
    recorrido(right(ind), (l + r) / 2 + 1, r);
    printf("%d %d: %d %d\n", l, r, _tree[ind].first, _tree[ind].second);
  }

 public:
  void build(vector<int> &data) {
    _data = data;
    _n = _data.size();
    _tree.assign(4 * _n, pair<int, int>(0, 0));
    build(1, 0, _n - 1);
  }
  void update(int ind1, int ind2, int newdata1, int newdata2) {
    _data[ind1] = newdata1;
    _data[ind2] = newdata2;
    update(1, 0, _n - 1, ind1, ind2);
  }
  bool query(int r) { return query(1, 0, _n - 1, 0, r).first != -1; }
  void recorrido() { recorrido(1, 0, _n - 1); }
} st;
int main() {
  if (fopen("input.txt", "r")) freopen("input.txt", "r", stdin);
  pot2.push_back(1);
  for (int i = 0; i < 20; i++) pot2.push_back(2 * pot2[i]);
  int n;
  scanf("%d ", &n);
  p.assign(n + 1, 0);
  for (int i = 1; i < n + 1; i++) scanf("%d ", &p[i]);
  d.assign(n + 1, 0);
  for (int i = 2; i < n + 1; i++) scanf("%d ", &d[i]);
  adj.assign(n + 1, vector<int>());
  for (int i = 2; i < n + 1; i++) adj[d[i]].push_back(i);
  lvl.assign(n + 1, -1);
  qu.push(1);
  lvl[1] = 0;
  while (!qu.empty()) {
    int u = qu.front();
    qu.pop();
    for (int i = 0; i < adj[u].size(); i++)
      if (adj[u][i] != d[u]) {
        lvl[adj[u][i]] = lvl[u] + 1;
        qu.push(adj[u][i]);
      }
  }
  dfs_first.assign(n + 1, -1);
  sk.push(pair<int, int>(1, 0));
  while (!sk.empty()) {
    pair<int, int> u = sk.top();
    sk.pop();
    if (dfs_first[u.first] == -1) dfs_first[u.first] = dfs_transversal.size();
    dfs_transversal.push_back(u.first);
    dfs_lvl.push_back(lvl[u.first]);
    if (u.second == adj[u.first].size()) continue;
    sk.push(pair<int, int>(u.first, u.second + 1));
    sk.push(pair<int, int>(adj[u.first][u.second], 0));
  }
  int tamrecorrido = dfs_lvl.size();
  sparse_table.assign(20, vector<int>(tamrecorrido, 0));
  for (int i = 0; i < tamrecorrido; i++)
    sparse_table[0][i] = dfs_transversal[i];
  for (int i = 1; i < 20; i++) {
    int salto = (1 << (i - 1));
    if (salto >= tamrecorrido) break;
    for (int j = 0; j < tamrecorrido - salto; j++)
      if (lvl[sparse_table[i - 1][j]] < lvl[sparse_table[i - 1][j + salto]]) {
        sparse_table[i][j] = sparse_table[i - 1][j];
      } else {
        sparse_table[i][j] = sparse_table[i - 1][j + salto];
      }
  }
  dualp.assign(n, 0);
  for (int i = 1; i < n + 1; i++) dualp[p[i]] = i;
  st.build(dualp);
  int q;
  scanf("%d ", &q);
  while (q--) {
    int t;
    scanf("%d ", &t);
    if (t == 1) {
      int x, y, px, py;
      scanf("%d %d ", &x, &y);
      px = p[x];
      py = p[y];
      st.update(px, py, y, x);
      p[x] = py;
      p[y] = px;
    } else {
      int lo = 0, hi = n;
      while (lo + 1 < hi) {
        int mi = (lo + hi) / 2;
        if (st.query(mi))
          lo = mi;
        else
          hi = mi;
      }
      printf("%d\n", hi);
    }
  }
  return 0;
}

```