#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void mx(T& x, const T& y) {
  if (x < y) x = y;
}
template <typename T>
inline void mn(T& x, const T& y) {
  if (y < x) x = y;
}
template <typename T>
inline int sz(const T& x) {
  return (int)x.size();
}
struct Update {
  int type;
  int indexOfStat;
  long long value;
  int indexOfUpdate;
  long long x;
  long long y;
};
istream& operator>>(istream& istr, Update& update) {
  return istr >> update.type >> update.indexOfStat >> update.value;
}
inline bool operator<(const Update& a, const Update& b) {
  return (a.x - a.y) * b.y > (b.x - b.y) * a.y;
}
const int SET = 1;
const int ADD = 2;
const int MUL = 3;
const int SET_AFTER_UPDATE = 4;
vector<vector<int> > addUpdates;
vector<Update> updates;
struct CMP {
  bool operator()(const pair<int, int>& a, const pair<int, int>& b) const {
    int x = addUpdates[a.first][a.second];
    int y = addUpdates[b.first][b.second];
    return updates[y] < updates[x];
  }
};
int main() {
  ios_base::sync_with_stdio(false);
  int k, n, m;
  cin >> k >> n >> m;
  vector<long long> init(k);
  for (int i = 0; i < (k); ++i) {
    cin >> init[i];
  }
  updates.resize(n);
  for (int i = 0; i < (n); ++i) {
    cin >> updates[i];
    updates[i].indexOfStat--;
    updates[i].indexOfUpdate = i;
  }
  vector<int> bestSetUpdate(k, -1);
  for (Update& update : updates) {
    if (update.type == SET) {
      int& oldBestSetUpdate = bestSetUpdate[update.indexOfStat];
      if (oldBestSetUpdate == -1 ||
          update.value > updates[oldBestSetUpdate].value) {
        oldBestSetUpdate = update.indexOfUpdate;
      }
    }
  }
  for (int i = 0; i < k; ++i) {
    int oldBestSetUpdate = bestSetUpdate[i];
    if (oldBestSetUpdate != -1 && updates[oldBestSetUpdate].value > init[i]) {
      updates[oldBestSetUpdate].value -= init[i];
      updates[oldBestSetUpdate].type = SET_AFTER_UPDATE;
    }
  }
  addUpdates.resize(k + 1);
  for (Update& update : updates) {
    if (update.type == ADD || update.type == SET_AFTER_UPDATE) {
      if (update.type == SET_AFTER_UPDATE) {
        update.type = SET;
      }
      addUpdates[update.indexOfStat].push_back(update.indexOfUpdate);
    }
    if (update.type == MUL) {
      addUpdates[k].push_back(update.indexOfUpdate);
      update.x = update.value;
      update.y = 1;
    }
  }
  for (int i = 0; i < k; ++i) {
    sort(addUpdates[i].begin(), addUpdates[i].end(),
         [&](int a, int b) { return updates[a].value > updates[b].value; });
    for (int j = 0; j < sz(addUpdates[i]); ++j) {
      int iUpdate = addUpdates[i][j];
      long long prev;
      if (j == 0) {
        prev = init[i];
      } else {
        prev = updates[addUpdates[i][j - 1]].x;
      }
      updates[iUpdate].x = updates[iUpdate].value + prev;
      updates[iUpdate].y = prev;
    }
  }
  priority_queue<pair<int, int>, vector<pair<int, int> >, CMP> q;
  for (int i = 0; i <= k; ++i) {
    sort(addUpdates[i].begin(), addUpdates[i].end(),
         [&](int a, int b) { return updates[a] < updates[b]; });
    if (sz(addUpdates[i]) > 0) {
      q.push(make_pair(i, 0));
    }
  }
  vector<int> ans;
  int iter = 0;
  while (iter < m && !q.empty()) {
    iter++;
    pair<int, int> top = q.top();
    q.pop();
    if (top.second + 1 < sz(addUpdates[top.first])) {
      q.push(make_pair(top.first, top.second + 1));
    }
    ans.push_back(addUpdates[top.first][top.second]);
  }
  cout << sz(ans) << endl;
  sort(ans.begin(), ans.end(),
       [&](int a, int b) { return updates[a].type < updates[b].type; });
  for (int x : ans) {
    cout << updates[x].indexOfUpdate + 1 << ' ';
  }
  cout << endl;
  return 0;
}
