Problem: Johnny is at a carnival which has n raffles. Raffle i has a prize with value pi. Each participant can put tickets in whichever raffles they choose (they may have more than one ticket in a single raffle). At the end of the carnival, one ticket is selected at random from each raffle, and the owner of the ticket wins the associated prize. A single person can win multiple prizes from different raffles. 

However, county rules prevent any one participant from owning more than half the tickets in a single raffle, i.e. putting more tickets in the raffle than all the other participants combined. To help combat this (and possibly win some prizes), the organizers started by placing a single ticket in each raffle, which they will never remove.

Johnny bought t tickets and is wondering where to place them. Currently, there are a total of li tickets in the i-th raffle. He watches as other participants place tickets and modify their decisions and, at every moment in time, wants to know how much he can possibly earn. Find the maximum possible expected value of Johnny's winnings at each moment if he distributes his tickets optimally. Johnny may redistribute all of his tickets arbitrarily between each update, but he may not place more than t tickets total or have more tickets in a single raffle than all other participants combined.

Input

The first line contains two integers n, t, and q (1 ≤ n, t, q ≤ 200 000) — the number of raffles, the number of tickets Johnny has, and the total number of updates, respectively.

The second line contains n space-separated integers pi (1 ≤ pi ≤ 1000) — the value of the i-th prize.

The third line contains n space-separated integers li (1 ≤ li ≤ 1000) — the number of tickets initially in the i-th raffle.

The last q lines contain the descriptions of the updates. Each description contains two integers tk, rk (1 ≤ tk ≤ 2, 1 ≤ rk ≤ n) — the type of the update and the raffle number. An update of type 1 represents another participant adding a ticket to raffle rk. An update of type 2 represents another participant removing a ticket from raffle rk.

It is guaranteed that, after each update, each raffle has at least 1 ticket (not including Johnny's) in it.

Output

Print q lines, each containing a single real number — the maximum expected value of Johnny's winnings after the k-th update. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6. 

Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if <image>.

Examples

Input

2 1 3
4 5
1 2
1 1
1 2
2 1


Output

1.666666667
1.333333333
2.000000000


Input

3 20 5
6 8 10
6 6 6
1 1
1 2
1 3
2 3
2 3


Output

12.000000000
12.000000000
11.769230769
12.000000000
12.000000000

Note

In the first case, Johnny only has one ticket to distribute. The prizes are worth 4 and 5, and the raffles initially have 1 and 2 tickets, respectively. After the first update, each raffle has 2 tickets, so Johnny has expected value <image> of winning by placing his ticket into the second raffle. The second update adds a ticket to the second raffle, so Johnny can win <image> in the first raffle. After the final update, Johnny keeps his ticket in the first raffle and wins <image>.

In the second case, Johnny has more tickets than he is allowed to spend. In particular, after the first update, there are 7, 6, and 6 tickets in each raffle, respectively, so Johnny can only put in 19 tickets, winning each prize with probability <image>. Also, note that after the last two updates, Johnny must remove a ticket from the last raffle in order to stay under <image> the tickets in the third raffle.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-9;
const int INF = 1e8 + 10;
long long GetGCD(long long a, long long b) {
  while (a > 0 && b > 0) {
    if (a >= b) {
      a %= b;
    } else {
      b %= a;
    }
  }
  return a + b;
}
struct TFrac {
  long long Num;
  long long Den;
  TFrac() : Num(0), Den(1) {}
  TFrac(long long num, long long den) : Num(num), Den(den) {}
  void Normalize() {
    if (Den < 0) {
      Den *= -1;
      Num *= -1;
    }
    long long g = GetGCD(abs(Num), abs(Den));
    Num /= g;
    Den /= g;
  }
  long double GetValue() const { return 1.0 * Num / Den; }
};
ostream& operator<<(ostream& outputStream, const TFrac& frac) {
  outputStream << "(" << frac.Num << " / " << frac.Den << ")";
  return outputStream;
}
bool operator<(const TFrac& lhs, const TFrac& rhs) {
  long long left = lhs.Num * rhs.Den;
  long long right = lhs.Den * rhs.Num;
  return left < right;
}
bool operator==(const TFrac& lhs, const TFrac& rhs) {
  long long left = lhs.Num * rhs.Den;
  long long right = lhs.Den * rhs.Num;
  return left == right;
}
bool operator<=(const TFrac& lhs, const TFrac& rhs) {
  return (lhs < rhs || lhs == rhs);
}
bool operator>(const TFrac& lhs, const TFrac& rhs) { return !(lhs <= rhs); }
bool operator>=(const TFrac& lhs, const TFrac& rhs) { return !(lhs < rhs); }
TFrac operator*(long long lhs, const TFrac& rhs) {
  return TFrac(rhs.Num * lhs, rhs.Den);
}
TFrac operator*(const TFrac& lhs, long long rhs) {
  return TFrac(lhs.Num * rhs, lhs.Den);
}
template <typename TGetter>
class THeap {
 public:
  THeap() : Getter() {}
  void Push(int item) {
    ExtendIndexes(item);
    Indexes[item] = T.size();
    T.push_back(item);
    GoUp(T.size() - 1);
  }
  int GetTop() const { return T[0]; }
  void Shift(int v) {
    GoUp(Indexes[v]);
    GoDown(Indexes[v]);
  }
  bool IsEmpty() const { return GetSize() == 0; }
  int GetSize() const { return T.size(); }
  const int NOT_EXIST = -1;
  vector<int> T;
  vector<int> Indexes;
  TGetter Getter;
  inline int GetLeft(int v) { return 2 * v + 1; }
  inline int GetRight(int v) { return 2 * v + 2; }
  inline int GetUp(int v) { return (v - 1) / 2; }
  void GoUp(int v) {
    while (v > 0 && Getter(T[v]) > Getter(T[GetUp(v)])) {
      Swap(v, GetUp(v));
      v = GetUp(v);
    }
  }
  void GoDown(int v) {
    while (GetLeft(v) < GetSize() || GetRight(v) < GetSize()) {
      int left = GetLeft(v);
      int right = GetRight(v);
      int index = v;
      TFrac val = Getter(T[v]);
      if (left < GetSize() && Getter(T[left]) > val) {
        index = left;
        val = Getter(T[left]);
      }
      if (right < GetSize() && Getter(T[right]) > val) {
        index = right;
        val = Getter(T[right]);
      }
      if (index == v) {
        break;
      } else {
        Swap(index, v);
        v = index;
      }
    }
  }
  void Swap(int v, int u) {
    swap(T[v], T[u]);
    Indexes[T[v]] = v;
    Indexes[T[u]] = u;
  }
  void ExtendIndexes(int index) {
    while (Indexes.size() <= index) {
      Indexes.push_back(NOT_EXIST);
    }
  }
};
int n;
int t;
vector<int> p;
vector<int> l;
vector<int> usedCount;
int allUsedCount;
TFrac GetElem(int i, int j) {
  return TFrac(1LL * p[i] * l[i], 1LL * (l[i] + j) * (l[i] + j + 1));
}
long double GetValue(int i) {
  return 1.0 * p[i] * usedCount[i] / (usedCount[i] + l[i]);
}
struct TNotUsedGetter {
 public:
  TFrac operator()(int index) const {
    if (usedCount[index] == l[index]) {
      return TFrac(0, 1);
    } else {
      return GetElem(index, usedCount[index]);
    }
  }
};
struct TUsedGetter {
 public:
  TFrac operator()(int index) const {
    if (usedCount[index] == 0) {
      return TFrac(-INF, 1);
    } else {
      return -1 * GetElem(index, usedCount[index] - 1);
    }
  }
};
THeap<TNotUsedGetter> notUsed;
THeap<TUsedGetter> used;
long double result;
void Del(int i) {
  if (usedCount[i] == 0) {
    return;
  }
  result -= GetElem(i, usedCount[i] - 1).GetValue();
  --usedCount[i];
  --allUsedCount;
  notUsed.Shift(i);
  used.Shift(i);
}
void Add(int i) {
  result += GetElem(i, usedCount[i]).GetValue();
  ++usedCount[i];
  ++allUsedCount;
  notUsed.Shift(i);
  used.Shift(i);
}
bool DelBest() {
  if (allUsedCount == 0) {
    return false;
  }
  Del(used.GetTop());
  return true;
}
bool AddBest() {
  if (allUsedCount == t) {
    return false;
  }
  int index = notUsed.GetTop();
  if (usedCount[index] == l[index]) {
    return false;
  }
  Add(index);
  return true;
}
void Init() {
  usedCount.assign(n, 0);
  allUsedCount = 0;
  for (int i = 0; i < n; ++i) {
    notUsed.Push(i);
    used.Push(i);
  }
  result = 0.0;
  for (int itr = 0; itr < t; ++itr) {
    if (!AddBest()) {
      break;
    }
  }
}
void Inc(int i) {
  result -= GetValue(i);
  ++l[i];
  notUsed.Shift(i);
  used.Shift(i);
  result += GetValue(i);
  DelBest();
  DelBest();
  while (AddBest()) {
  }
}
void Dec(int i) {
  if (usedCount[i] == l[i]) {
    Del(i);
  }
  result -= GetValue(i);
  --l[i];
  notUsed.Shift(i);
  used.Shift(i);
  result += GetValue(i);
  DelBest();
  DelBest();
  while (AddBest()) {
  }
}
void Gen() {
  freopen("input.txt", "w", stdout);
  const int N = 2e5;
  const int T = 2e5;
  const int Q = 2e5;
  const int MAX_P = 1000;
  const int MAX_L = 1000;
  cout << N << " " << T << " " << Q << endl;
  for (int i = 0; i < N; ++i) {
    cout << MAX_P << " ";
  }
  cout << endl;
  for (int i = 0; i < N; ++i) {
    cout << MAX_L << " ";
  }
  cout << endl;
  srand(42);
  vector<int> cur(N, MAX_L);
  const auto& gen = [](int left, int right) {
    return rand() % (right - left + 1) + left;
  };
  for (int i = 0; i < Q; ++i) {
    int index = gen(0, N - 1);
    int tp;
    while (true) {
      tp = gen(1, 2);
      if (tp == 2 && cur[index] == 1) {
        continue;
      }
      cur[index] += (tp == 2 ? -1 : 1);
      cout << tp << " " << index + 1 << '\n';
      break;
    }
  }
  cout.flush();
  exit(0);
}
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(nullptr);
  int q;
  scanf("%d%d%d", &n, &t, &q);
  p.resize(n);
  for (int i = 0; i < n; ++i) {
    scanf("%d", &p[i]);
  }
  l.resize(n);
  for (int i = 0; i < n; ++i) {
    scanf("%d", &l[i]);
  }
  Init();
  while (q--) {
    int tp;
    int x;
    scanf("%d%d", &tp, &x);
    --x;
    if (tp == 1) {
      Inc(x);
    } else {
      Dec(x);
    }
    printf("%.17f\n", (double)result);
  }
  return 0;
}