#include <bits/stdc++.h>
int readInt();
int N, T, Q;
int TCUR;
int P[200000 + 1];
int L[200000 + 1];
int COUNT[200000 + 1];
struct FRAC {
  long long up;
  long long down;
  FRAC operator-(const FRAC &rhs) const {
    FRAC f = {up * rhs.down - down * rhs.up, down * rhs.down};
    return f.yakbun();
  }
  FRAC &yakbun() {
    long long g = gcd(abs(up), down);
    up /= g;
    down /= g;
    return *this;
  }
  bool operator<(const FRAC &rhs) {
    if (down == 0) return false;
    if (rhs.down == 0) return true;
    FRAC diff = *this - rhs;
    return (diff.up < 0);
  }

 private:
  long long gcd(long long a, long long b) {
    if (!a) return b;
    if (!b) return a;
    if (a > b)
      return gcd(a % b, b);
    else
      return gcd(a, b % a);
  }
};
FRAC Expectation(int i, int cnt) { return {cnt * (long long)P[i], L[i] + cnt}; }
FRAC Price(int i, int cnt) {
  if (cnt == L[i]) {
    return {1, 0};
  }
  FRAC cur = Expectation(i, cnt);
  FRAC upd = Expectation(i, cnt + 1);
  return (upd - cur);
}
bool HasSpace(int i) { return (COUNT[i] < L[i]); }
class Heap {
 public:
  std::function<bool(int, int, int, int)> CompareFunc;
  int heap[200000 + 1];
  int hinv[200000 + 1];
  void BubbleDown(int i) {
    int pos = hinv[i];
    while (2 * pos <= N) {
      int maxpos = pos;
      int maxi = i;
      int maxc = COUNT[i];
      if (CompareFunc(maxi, maxc, heap[(2 * (pos))],
                      COUNT[heap[(2 * (pos))]])) {
        maxpos = (2 * (pos));
        maxi = heap[(2 * (pos))];
        maxc = COUNT[maxi];
      }
      if ((2 * (pos) + 1) <= N && CompareFunc(maxi, maxc, heap[(2 * (pos) + 1)],
                                              COUNT[heap[(2 * (pos) + 1)]])) {
        maxpos = (2 * (pos) + 1);
      }
      if (maxpos == pos) break;
      heap[pos] = heap[maxpos];
      hinv[heap[pos]] = pos;
      pos = maxpos;
    }
    heap[pos] = i;
    hinv[i] = pos;
  }
  void BubbleUp(int i) {
    int pos = hinv[i];
    while (pos > 1) {
      int minpos = pos;
      if (CompareFunc(heap[((pos) / 2)], COUNT[heap[((pos) / 2)]], i,
                      COUNT[i])) {
        minpos = ((pos) / 2);
      }
      if (minpos == pos) break;
      heap[pos] = heap[minpos];
      hinv[heap[pos]] = pos;
      pos = minpos;
    }
    heap[pos] = i;
    hinv[i] = pos;
  }
  void BuildMaxHeap() {
    for (int i = 1; i <= N; i++) {
      heap[i] = hinv[i] = i;
    }
    for (int i = N / 2; i >= 1; i--) {
      BubbleDown(heap[i]);
    }
  }
  void Update(int i) {
    BubbleUp(i);
    BubbleDown(i);
  }
  int Top() { return heap[1]; }
};
void Get() {
  N = readInt();
  T = readInt();
  Q = readInt();
  for (int i = 1; i <= N; i++) P[i] = readInt();
  for (int i = 1; i <= N; i++) L[i] = readInt();
  memset(COUNT + 1, 0, sizeof(COUNT[1]) * N);
}
Heap hVacant, hFilled;
double sum = 0, c = 0;
void KahanUpdate(double diff) {
  double y = diff - c;
  double t = sum + y;
  c = (t - sum) - y;
  sum = t;
}
void UpdateCount(int i, int val) {
  int prev = COUNT[i];
  TCUR += val - prev;
  COUNT[i] = val;
  hVacant.Update(i);
  hFilled.Update(i);
}
void Refresh(int i) { UpdateCount(i, COUNT[i]); }
void IncrementCount(int i) {
  int c = COUNT[i];
  UpdateCount(i, c + 1);
  FRAC price = Price(i, c);
  KahanUpdate(price.up / (double)price.down);
}
void DecrementCount(int i) {
  int c = COUNT[i];
  UpdateCount(i, c - 1);
  FRAC price = Price(i, c - 1);
  KahanUpdate(-price.up / (double)price.down);
}
void GreedyFill() {
  while (HasSpace(hVacant.Top()) && TCUR < T) {
    IncrementCount(hVacant.Top());
  }
}
void GreedyMove() {
  while (1) {
    int vtop = hVacant.Top();
    if (!HasSpace(vtop)) break;
    int ftop = hFilled.Top();
    if (COUNT[ftop] == 0) break;
    FRAC vprice = Price(vtop, COUNT[vtop]);
    FRAC fprice = Price(ftop, COUNT[ftop] - 1);
    if (!(fprice < vprice)) break;
    DecrementCount(ftop);
    IncrementCount(vtop);
  }
}
void IncrementL(int i) {
  FRAC p1 = Expectation(i, COUNT[i]);
  KahanUpdate(-p1.up / (double)p1.down);
  L[i]++;
  FRAC p2 = Expectation(i, COUNT[i]);
  KahanUpdate(p2.up / (double)p2.down);
}
void DecrementL(int i) {
  FRAC p1 = Expectation(i, COUNT[i]);
  KahanUpdate(-p1.up / (double)p1.down);
  L[i]--;
  FRAC p2 = Expectation(i, COUNT[i]);
  KahanUpdate(p2.up / (double)p2.down);
}
void Calc() {
  hVacant.CompareFunc = [](int i, int cnti, int j, int cntj) -> bool {
    if (cntj == L[j]) return false;
    if (cnti == L[i]) return true;
    return Price(i, cnti) < Price(j, cntj);
  };
  hVacant.BuildMaxHeap();
  hFilled.CompareFunc = [](int i, int cnti, int j, int cntj) -> bool {
    if (cntj == 0) return false;
    if (cnti == 0) return true;
    return Price(j, cntj - 1) < Price(i, cnti - 1);
  };
  hFilled.BuildMaxHeap();
  TCUR = 0;
  GreedyFill();
  for (int q = 0; q < Q; q++) {
    int t = readInt();
    int r = readInt();
    if (t == 1) {
      IncrementL(r);
    } else {
      if (COUNT[r] == L[r]) {
        DecrementCount(r);
      }
      DecrementL(r);
    }
    Refresh(r);
    GreedyMove();
    GreedyFill();
    printf("%.10lf\n", sum);
  }
}
int main(int argc, char *argv[]) {
  Get();
  Calc();
  return 0;
}
char buf[1048576];
char *p = buf + 1048576;
inline char readChar() {
  if (p == buf + 1048576) {
    fread(buf, 1, 1048576, stdin);
    p = buf;
  }
  return *p++;
}
int readInt() {
  char c;
  do {
    c = readChar();
  } while (c < '0');
  int ret = 0;
  do {
    ret = ret * 10 + (c - '0');
  } while ((c = readChar()) >= '0');
  return ret;
}
