#include <bits/stdc++.h>
using namespace std;
class SegmentTree {
 public:
  class Node {
   public:
    int orVal, minVal, left, right, mid;
    Node *leftChild, *rightChild;
    Node(int a, int b) {
      left = a;
      right = b;
      mid = (a + b) / 2;
      leftChild = NULL;
      rightChild = NULL;
    }
    void create(vector<int> &v) {
      if (left == right) {
        orVal = v[left];
        minVal = orVal;
        return;
      }
      leftChild = new Node(left, mid);
      rightChild = new Node(mid + 1, right);
      leftChild->create(v);
      rightChild->create(v);
      orVal = leftChild->orVal | rightChild->orVal;
      minVal = min(leftChild->minVal, rightChild->minVal);
    }
    int orQuery(int &low, int &high) {
      if (right < low || left > high) {
        return 0;
      }
      if (low <= left && right <= high) {
        return orVal;
      }
      return leftChild->orQuery(low, high) | rightChild->orQuery(low, high);
    }
    int minQuery(int &low, int &high) {
      if (right < low || left > high) {
        return 1000000000;
      }
      if (low <= left && right <= high) {
        return minVal;
      }
      return min(leftChild->minQuery(low, high),
                 rightChild->minQuery(low, high));
    }
  };
  Node *root;
  SegmentTree(int n) { root = new Node(0, n - 1); }
  void create(vector<int> &v) { root->create(v); }
  int minQuery(int low, int high) { return root->minQuery(low, high); }
  int orQuery(int low, int high) { return root->orQuery(low, high); }
};
int gcd(int a, int b) {
  while (a != b && b != 0) {
    a %= b;
    swap(a, b);
  }
  return a;
}
int main() {
  ios::sync_with_stdio(0);
  long long n, sum = 0;
  cin >> n;
  long long a[n], b[n], max1, max2;
  for (int i = 0; i < n; i++) {
    cin >> a[i];
    sum += a[i];
  }
  for (int i = 0; i < n; i++) {
    cin >> b[i];
  }
  max1 = max(b[0], b[1]);
  max2 = min(b[1], b[0]);
  for (int i = 2; i < n; i++) {
    if (b[i] > max1) {
      max2 = max1;
      max1 = b[i];
    } else if (b[i] > max2) {
      max2 = b[i];
    }
  }
  if (sum <= max1 + max2) {
    cout << "YES";
    return 0;
  }
  cout << "NO";
}

### Prompt

Generate a Cpp solution to the following problem:

Jafar has n cans of cola. Each can is described by two integers: remaining volume of cola ai and can's capacity bi (ai ≤  bi).

Jafar has decided to pour all remaining cola into just 2 cans, determine if he can do this or not!

Input

The first line of the input contains one integer n (2 ≤ n ≤ 100 000) — number of cola cans.

The second line contains n space-separated integers a1, a2, ..., an (0 ≤ ai ≤ 109) — volume of remaining cola in cans.

The third line contains n space-separated integers that b1, b2, ..., bn (ai ≤ bi ≤ 109) — capacities of the cans.

Output

Print "YES" (without quotes) if it is possible to pour all remaining cola in 2 cans. Otherwise print "NO" (without quotes).

You can print each letter in any case (upper or lower).

Examples

Input

2
3 5
3 6


Output

YES


Input

3
6 8 9
6 10 12


Output

NO


Input

5
0 0 5 0 0
1 1 8 10 5


Output

YES


Input

4
4 1 0 3
5 2 2 3


Output

YES

Note

In the first sample, there are already 2 cans, so the answer is "YES".

### Response

```cpp
#include <bits/stdc++.h>
using namespace std;
class SegmentTree {
 public:
  class Node {
   public:
    int orVal, minVal, left, right, mid;
    Node *leftChild, *rightChild;
    Node(int a, int b) {
      left = a;
      right = b;
      mid = (a + b) / 2;
      leftChild = NULL;
      rightChild = NULL;
    }
    void create(vector<int> &v) {
      if (left == right) {
        orVal = v[left];
        minVal = orVal;
        return;
      }
      leftChild = new Node(left, mid);
      rightChild = new Node(mid + 1, right);
      leftChild->create(v);
      rightChild->create(v);
      orVal = leftChild->orVal | rightChild->orVal;
      minVal = min(leftChild->minVal, rightChild->minVal);
    }
    int orQuery(int &low, int &high) {
      if (right < low || left > high) {
        return 0;
      }
      if (low <= left && right <= high) {
        return orVal;
      }
      return leftChild->orQuery(low, high) | rightChild->orQuery(low, high);
    }
    int minQuery(int &low, int &high) {
      if (right < low || left > high) {
        return 1000000000;
      }
      if (low <= left && right <= high) {
        return minVal;
      }
      return min(leftChild->minQuery(low, high),
                 rightChild->minQuery(low, high));
    }
  };
  Node *root;
  SegmentTree(int n) { root = new Node(0, n - 1); }
  void create(vector<int> &v) { root->create(v); }
  int minQuery(int low, int high) { return root->minQuery(low, high); }
  int orQuery(int low, int high) { return root->orQuery(low, high); }
};
int gcd(int a, int b) {
  while (a != b && b != 0) {
    a %= b;
    swap(a, b);
  }
  return a;
}
int main() {
  ios::sync_with_stdio(0);
  long long n, sum = 0;
  cin >> n;
  long long a[n], b[n], max1, max2;
  for (int i = 0; i < n; i++) {
    cin >> a[i];
    sum += a[i];
  }
  for (int i = 0; i < n; i++) {
    cin >> b[i];
  }
  max1 = max(b[0], b[1]);
  max2 = min(b[1], b[0]);
  for (int i = 2; i < n; i++) {
    if (b[i] > max1) {
      max2 = max1;
      max1 = b[i];
    } else if (b[i] > max2) {
      max2 = b[i];
    }
  }
  if (sum <= max1 + max2) {
    cout << "YES";
    return 0;
  }
  cout << "NO";
}

```