package chelper;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Random;
import java.util.Set;

import io.InputReader;
import io.OutputWriter;
import misc.SimpleSavingChelperSolution;


public class E extends SimpleSavingChelperSolution {

  private int[][] colors;
  private int[][] colorsH;
  private int[][] colorsV;
  private int sqrt;
  private int n;
  private int m;
  private int q;

  public void solve(int testNumber, InputReader in, OutputWriter out) {
    wrapSolve(testNumber, in, out);
  }

  class Node1 {
    int l, r, m;

    Node1 childLeft, childRight;

    Set<Integer> propagateSet = new HashSet<>();
    Set<Integer> propagateRemove = new HashSet<>();

    Node1(int l, int r) {
      this.l = l;
      this.r = r;

      m = (l + r) / 2;

      if (r - l != 1) {
        childLeft = new Node1(l, m);
        childRight = new Node1(m, r);
      }
    }

    void prop() {
      if (r - l <= 1) {
        return;
      }

      childLeft.propagateSet.addAll(propagateSet);
      childLeft.propagateSet.removeAll(propagateRemove);
      childLeft.propagateRemove.addAll(propagateRemove);
      childLeft.propagateRemove.removeAll(propagateSet);

      childRight.propagateSet.addAll(propagateSet);
      childRight.propagateSet.removeAll(propagateRemove);
      childRight.propagateRemove.addAll(propagateRemove);
      childRight.propagateRemove.removeAll(propagateSet);

      propagateSet.clear();
      propagateRemove.clear();
    }

    Set<Integer> get(int x) {
      if (l == x && r == x + 1) {
        return propagateSet;
      }

      prop();

      if (x < m) {
        return childLeft.get(x);
      }
      return childRight.get(x);
    }

    void add(int ll, int rr, int val) {
      if (l == ll && r == rr) {
        propagateSet.add(val);
        propagateRemove.remove(val);
        return;
      }

      prop();

      if (ll < m) {
        childLeft.add(ll, Math.min(m, rr), val);
      }
      if (rr > m) {
        childRight.add(Math.max(m, ll), rr, val);
      }
    }

    void remove(int ll, int rr, int val) {
      if (l == ll && r == rr) {
        propagateSet.remove(val);
        propagateRemove.add(val);
        return;
      }

      prop();

      if (ll < m) {
        childLeft.remove(ll, Math.min(m, rr), val);
      }
      if (rr > m) {
        childRight.remove(Math.max(m, ll), rr, val);
      }
    }
  }

  class Node2 {
    int l, in
  }

  @Override
  public void solve(int testNumber) {
    sqrt = 50;
    n = in.nextInt();
    m = in.nextInt();
    q = in.nextInt();

//    int[][] node = new int[n][m];
    colors = new int[n][m];
    colorsH = new int[n][sqrt];
    colorsV = new int[sqrt][m];

    for (int i = 0; i < q; i++) {
      int type = in.nextInt();
      int x1 = in.nextInt() - 1;
      int y1 = in.nextInt() - 1;
      int x2 = in.nextInt() - 1;
      int y2 = in.nextInt() - 1;

//      if (type)
    }

    Node1 root = new Node1(0, 10);
    Random random = new Random();
    List<Set<Integer>> underlying = new ArrayList<>();
    for (int i = 0; i < 10; i++) {
      underlying.add(new HashSet<>());
    }
    for (int i = 0; i < 500; i++) {
      int l = random.nextInt(10);
      int r = random.nextInt(10);
      if (r < l) {
        int t = l;
        l = r;
        r = t;
      }
      r++;
      int c = random.nextInt(10);
      boolean add = random.nextBoolean();

//      int l = 1;
//      int r = 6;
//      int c = 1;
//      boolean add = true;


      for (int j = l; j < r; j++) {
        if (add) {
          underlying.get(j).add(c);
        } else {
          underlying.get(j).remove(c);
        }
      }
      if (add) {
        root.add(l, r, c);
      } else {
        root.remove(l, r, c);
      }
//      out.println((add ? "+" : "-") + " " + l + " " + r + " " + c);
    }
    out.println();

    for (int i = 0; i < 10; i++) {
      out.println(i + " 1 " + underlying.get(i));
      out.println(i + " 2 " + root.get(i));
      out.println();
    }
  }
}