#include <cstdio>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <cmath>
#include <iomanip>
#include <cassert>
#include <bitset>
using namespace std;

typedef pair<int, int> P;
#define rep(i, n) for (int i=0; i<(n); i++)
#define all(c) (c).begin(), (c).end()
#define uniq(c) c.erase(unique(all(c)), (c).end())
#define index(xs, x) (int)(lower_bound(all(xs), x) - xs.begin())
#define _1 first
#define _2 second
#define pb push_back
#define INF 1145141919
#define MOD 1000000007
const int B = 450;
const int MAX_S = (200000/B)+10;

int N, Q, S;
bool lazy[2][MAX_S];
int A[2][200000+B];
int M[2][MAX_S];

void push(int k, int b) {
  if (!lazy[k][b]) return;
  rep(i, B) A[k][b*B+i] = A[k^1][b*B+i];
  lazy[k][b] = false;
}

signed main() {
  ios::sync_with_stdio(false); cin.tie(0);
  cin >> N;
  S = (N-1)/B+1;
  rep(k, 2) {
    rep(i, S) M[k][i] = INF;
    rep(i, N+B) A[k][i] = INF;
    rep(i, N) cin >> A[k][i], M[k][i/B] = min(M[k][i/B], A[k][i]);
  }
  cin >> Q;
  rep(i, Q) {
    int type, y, z;
    cin >> type >> y >> z;
    type--;
    int k = type%2;
    if (type/2 == 0) {
      y--;
      int b = y/B;
      push(k, b);
      push(k^1, b);
      A[k][y] = z;
      M[k][b] = INF;
      rep(i, B) M[k][b] = min(M[k][b], A[k][b*B+i]);
    }
    else if (type/2 == 1) {
      y--, z--;
      // min [y, z]
      int lb=y/B, rb=z/B, m = INF;
      push(k, lb);
      push(k, rb);
      if (lb == rb) {
        for (int i=y; i<=z; i++) m = min(m, A[k][i]);
      }
      else {
        for (int i=y; i<(lb+1)*B; i++) m = min(m, A[k][i]);
        for (int i=rb*B; i<=z; i++) m = min(m, A[k][i]);
        for (int b=lb+1; b<=rb-1; b++) m = min(m, M[k][b]);
      }
      cout << m << "\n";
    }
    else {
      rep(b, S) {
        if (!lazy[k^1][b]) {
          lazy[k][b] = true;
          M[k][b] = M[k^1][b];
        }
      }
    }
  }
  return 0;
}


### Prompt

Please formulate a Cpp solution to the following problem:

Problem

Given two sequences of length $ N $, $ A $ and $ B $. First, the $ i $ item in the sequence $ A $ is $ a_i $, and the $ i $ item in the sequence $ B $ is $ b_i $.

Since a total of $ Q $ of statements of the following format are given, create a program that processes in the given order.

Each statement is represented by three integers $ x, y, z $.

* Set the value of the $ y $ item in the sequence $ A $ to $ z $. (When $ x = 1 $)
* Set the value of the $ y $ item in the sequence $ B $ to $ z $. (When $ x = 2 $)
* Find and report the smallest value in the $ z $ item from the $ y $ item in the sequence $ A $. (When $ x = 3 $)
* Find and report the smallest value in the $ z $ item from the $ y $ item in the sequence $ B $. (When $ x = 4 $)
* Change the sequence $ A $ to be exactly the same as the sequence $ B $. (When $ x = 5 $)
* Change the sequence $ B $ to be exactly the same as the sequence $ A $. (When $ x = 6 $)

Constraints

The input satisfies the following conditions.

* $ 2 \ le N \ le 2 \ times 10 ^ 5 $
* $ 2 \ le Q \ le 2 \ times 10 ^ 5 $
* $ 1 \ le a_i \ le 10 ^ 9 $
* $ 1 \ le b_i \ le 10 ^ 9 $
* $ 1 \ le x_i \ le 6 $
* $ 1 \ le y_i \ le N $ (when $ 1 \ le x_i \ le 4 $)
* $ y_i = -1 $ (when $ x_i = 5, 6 $)
* $ 1 \ le z_i \ le 10 ^ 9 $ (when $ x_i = 1, 2 $)
* $ y_i \ le z_i \ le N $ (when $ x_i = 3, 4 $)
* $ z_i = -1 $ (when $ x_i = 5, 6 $)
* All inputs are integers

Input

The input is given in the following format.

$ N $
$ a_ {1} $ $ a_ {2} $ ... $ a_ {N} $
$ b_ {1} $ $ b_ {2} $ ... $ b_ {N} $
$ Q $
$ x_1 $ $ y_1 $ $ z_1 $
$ x_2 $ $ y_2 $ $ z_2 $
...
$ x_Q $ $ y_Q $ $ z_Q $

Output

Every time a statement of $ x = 3 $ or $ x = 4 $ is given by input, the found value is output on one line.

Example

Input

5
1 3 5 7 9
6 2 3 2 6
10
1 3 4
3 4 5
4 2 3
5 -1 -1
2 3 8
3 2 5
4 3 3
1 1 1
6 -1 -1
3 1 5


Output

7
2
2
8
1

### Response

```cpp
#include <cstdio>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <cmath>
#include <iomanip>
#include <cassert>
#include <bitset>
using namespace std;

typedef pair<int, int> P;
#define rep(i, n) for (int i=0; i<(n); i++)
#define all(c) (c).begin(), (c).end()
#define uniq(c) c.erase(unique(all(c)), (c).end())
#define index(xs, x) (int)(lower_bound(all(xs), x) - xs.begin())
#define _1 first
#define _2 second
#define pb push_back
#define INF 1145141919
#define MOD 1000000007
const int B = 450;
const int MAX_S = (200000/B)+10;

int N, Q, S;
bool lazy[2][MAX_S];
int A[2][200000+B];
int M[2][MAX_S];

void push(int k, int b) {
  if (!lazy[k][b]) return;
  rep(i, B) A[k][b*B+i] = A[k^1][b*B+i];
  lazy[k][b] = false;
}

signed main() {
  ios::sync_with_stdio(false); cin.tie(0);
  cin >> N;
  S = (N-1)/B+1;
  rep(k, 2) {
    rep(i, S) M[k][i] = INF;
    rep(i, N+B) A[k][i] = INF;
    rep(i, N) cin >> A[k][i], M[k][i/B] = min(M[k][i/B], A[k][i]);
  }
  cin >> Q;
  rep(i, Q) {
    int type, y, z;
    cin >> type >> y >> z;
    type--;
    int k = type%2;
    if (type/2 == 0) {
      y--;
      int b = y/B;
      push(k, b);
      push(k^1, b);
      A[k][y] = z;
      M[k][b] = INF;
      rep(i, B) M[k][b] = min(M[k][b], A[k][b*B+i]);
    }
    else if (type/2 == 1) {
      y--, z--;
      // min [y, z]
      int lb=y/B, rb=z/B, m = INF;
      push(k, lb);
      push(k, rb);
      if (lb == rb) {
        for (int i=y; i<=z; i++) m = min(m, A[k][i]);
      }
      else {
        for (int i=y; i<(lb+1)*B; i++) m = min(m, A[k][i]);
        for (int i=rb*B; i<=z; i++) m = min(m, A[k][i]);
        for (int b=lb+1; b<=rb-1; b++) m = min(m, M[k][b]);
      }
      cout << m << "\n";
    }
    else {
      rep(b, S) {
        if (!lazy[k^1][b]) {
          lazy[k][b] = true;
          M[k][b] = M[k^1][b];
        }
      }
    }
  }
  return 0;
}


```