// Checker for problem I
// Author: Adam Polak

#include <assert.h>
#include <stdio.h>
#include <stdlib.h>

#include <utility>
using namespace std;

const int N = 10 * 1000 + 2;
const int MAX_NUM_OPS = 9*9*9*9*9*9;
const int NIL = -1;

int n, p[N];

int key[N], left[N], right[N], size[N];

int Size(int a) { return a == NIL ? 0 : size[a]; }

void UpdateSize(int a) { size[a] = 1 + Size(left[a]) + Size(right[a]); }

int Merge(int a, int b) {
  if (a == NIL) return b;
  if (b == NIL) return a;
  if (key[a] < key[b]) {
    right[a] = Merge(right[a], b);
    UpdateSize(a);
    return a;
  } else {  // key[a] >= key[b]
    left[b] = Merge(a, left[b]);
    UpdateSize(b);
    return b;
  }
}

pair<int, int> Split(int a, int k) {
  assert(Size(a) >= k);
  if (k == 0) return make_pair(NIL, a);
  if (Size(left[a]) >= k) {
    pair<int, int> temp = Split(left[a], k);
    left[a] = temp.second;
    UpdateSize(a);
    return make_pair(temp.first, a);
  } else {
    pair<int, int> temp = Split(right[a], k - Size(left[a]) - 1);
    right[a] = temp.first;
    UpdateSize(a);
    return make_pair(a, temp.second);
  }
}

int Init() {
  for (int i = 0; i < n + 2; ++i) {
    left[i] = right[i] = NIL;
    size[i] = 1;
  }
  int root = 0;
  for (int i = 1; i < n + 2; ++i)
    root = Merge(root, i);
  return root;
}

int Swap(int root, int from, int to) {
  to++;
  int mid = (from + to) / 2;
  pair<int, int> temp;
  temp = Split(root, from);
  int a = temp.first;
  temp = Split(temp.second, mid - from);
  int b = temp.first;
  temp = Split(temp.second, to - mid);
  int c = temp.first;
  int d = temp.second;
  root = Merge(Merge(a, c), Merge(b, d));
  return root;
}

int FlushToP(int node, int it=0) {
  if (node == NIL) return it;
  it = FlushToP(left[node], it);
  p[it++] = node;
  return FlushToP(right[node], it);
} 

int main(int argc, char* argv[]) {
  srand48(13);
  for (int i = 0; i < N; ++i) key[i] = lrand48();

  FILE* in = fopen(argv[1], "r");
  FILE* out = fopen(argv[3], "r");

  int Z;
  fscanf(in, "%d", &Z);
  while (Z--) {
    fscanf(in, "%d", &n);

    int num_ops;
    fscanf(out, "%d", &num_ops);
    assert(0 <= num_ops <= MAX_NUM_OPS);
    int root = Init();
    while (num_ops--) {
      int from, to;
      fscanf(out, "%d%d", &from, &to);
      assert(1 <= from && from <= to & to <= n);
      assert((to - from + 1) % 2 == 0);
      root = Swap(root, from, to);
    }

    FlushToP(root);

    for (int i = 0; i < n; ++i) {
      int a;
      fscanf(in, "%d", &a);
      assert(p[a] == i + 1);
    }

    printf("OK\n");
  }
  return 0;
}