Problem: Yash is finally tired of computing the length of the longest Fibonacci-ish sequence. He now plays around with more complex things such as Fibonacci-ish potentials. 

Fibonacci-ish potential of an array ai is computed as follows: 

  1. Remove all elements j if there exists i < j such that ai = aj. 
  2. Sort the remaining elements in ascending order, i.e. a1 < a2 < ... < an. 
  3. Compute the potential as P(a) = a1·F1 + a2·F2 + ... + an·Fn, where Fi is the i-th Fibonacci number (see notes for clarification). 



You are given an array ai of length n and q ranges from lj to rj. For each range j you have to compute the Fibonacci-ish potential of the array bi, composed using all elements of ai from lj to rj inclusive. Find these potentials modulo m.

Input

The first line of the input contains integers of n and m (1 ≤ n, m ≤ 30 000) — the length of the initial array and the modulo, respectively.

The next line contains n integers ai (0 ≤ ai ≤ 109) — elements of the array.

Then follow the number of ranges q (1 ≤ q ≤ 30 000).

Last q lines contain pairs of indices li and ri (1 ≤ li ≤ ri ≤ n) — ranges to compute Fibonacci-ish potentials.

Output

Print q lines, i-th of them must contain the Fibonacci-ish potential of the i-th range modulo m.

Example

Input

5 10
2 1 2 1 2
2
2 4
4 5


Output

3
3

Note

For the purpose of this problem define Fibonacci numbers as follows: 

  1. F1 = F2 = 1. 
  2. Fn = Fn - 1 + Fn - 2 for each n > 2. 



In the first query, the subarray [1,2,1] can be formed using the minimal set {1,2}. Thus, the potential of this subarray is 1*1+2*1=3.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
static const int T = 30016;
static_assert(T % 64 == 0, "");
struct bs {
  union {
    uint64_t bits[T / 64];
    uint8_t ch[T / 8];
  };
  bs() : bits{} {}
  bool operator[](int ind) { return ch[ind >> 3] & (1 << (ind & 7)); }
  void set(int ind) { ch[ind >> 3] = 1 << (ind & 7); }
};
inline bs operator|(const bs& a, const bs& b) {
  bs r;
  for (int i = (0); i < (T / 64); i++) r.bits[i] = a.bits[i] | b.bits[i];
  return r;
}
inline bs& operator|=(bs& a, const bs& b) { return a = a | b; }
int N;
vector<bs> v(2 * T);
bs get(int l, int r) {
  bs ret;
  for (l += N, r += N; l < r; l /= 2, r /= 2) {
    if (l & 1) ret |= v[l++];
    if (r & 1) ret |= v[--r];
  }
  return ret;
}
int num[T], fib[T];
template <int>
inline __attribute__((always_inline)) void deal(int nu, int& c, uint64_t& ans) {
  ans += (uint32_t)fib[c] * (uint32_t)nu;
  c++;
}
template <>
inline __attribute__((always_inline)) void deal<0>(int nu, int& c,
                                                   uint64_t& ans) {}
signed main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  int q, mod;
  ignore = scanf("%d%d", &N, &mod);
  map<int, vector<int> > mp;
  for (int i = (0); i < (N); i++) {
    int k;
    ignore = scanf("%d", &k);
    mp[k].push_back(i);
  }
  int a = 0, mx = (int)mp.size();
  for (auto it = mp.begin(); it != mp.end(); it++) {
    for (int i : it->second) v[N + i].set(a);
    num[a++] = (it->first) % mod;
  }
  for (int i = N; i-- > 0;) v[i] = v[2 * i] | v[(2 * i) ^ 1];
  fib[0] = fib[1] = 1 % mod;
  for (int i = (2); i < (T); i++) fib[i] = (fib[i - 1] + fib[i - 2]) % mod;
  ignore = scanf("%d", &q);
  vector<pair<int, int> > que(q);
  for (int i = (0); i < (q); i++) {
    ignore = scanf("%d%d", &(que[i].first), &(que[i].second));
    que[i].first--;
  }
  for (int i = (0); i < (q); i++) {
    bs b = get(que[i].first, que[i].second);
    int c = 0;
    uint64_t ans = 0;
    for (int j = 0; j < mx; j += 8) {
      int* nums = num + j;
      switch (b.ch[j >> 3]) {
        case 0: {
          deal<0 & 1>(nums[0], c, ans);
          deal<0 & 2>(nums[1], c, ans);
          deal<0 & 4>(nums[2], c, ans);
          deal<0 & 8>(nums[3], c, ans);
          deal<0 & 16>(nums[4], c, ans);
          deal<0 & 32>(nums[5], c, ans);
          deal<0 & 64>(nums[6], c, ans);
          deal<0 & 128>(nums[7], c, ans);
          break;
        };
        case 1: {
          deal<1 & 1>(nums[0], c, ans);
          deal<1 & 2>(nums[1], c, ans);
          deal<1 & 4>(nums[2], c, ans);
          deal<1 & 8>(nums[3], c, ans);
          deal<1 & 16>(nums[4], c, ans);
          deal<1 & 32>(nums[5], c, ans);
          deal<1 & 64>(nums[6], c, ans);
          deal<1 & 128>(nums[7], c, ans);
          break;
        };
        case 2: {
          deal<2 & 1>(nums[0], c, ans);
          deal<2 & 2>(nums[1], c, ans);
          deal<2 & 4>(nums[2], c, ans);
          deal<2 & 8>(nums[3], c, ans);
          deal<2 & 16>(nums[4], c, ans);
          deal<2 & 32>(nums[5], c, ans);
          deal<2 & 64>(nums[6], c, ans);
          deal<2 & 128>(nums[7], c, ans);
          break;
        };
        case 3: {
          deal<3 & 1>(nums[0], c, ans);
          deal<3 & 2>(nums[1], c, ans);
          deal<3 & 4>(nums[2], c, ans);
          deal<3 & 8>(nums[3], c, ans);
          deal<3 & 16>(nums[4], c, ans);
          deal<3 & 32>(nums[5], c, ans);
          deal<3 & 64>(nums[6], c, ans);
          deal<3 & 128>(nums[7], c, ans);
          break;
        };
        case 4: {
          deal<4 & 1>(nums[0], c, ans);
          deal<4 & 2>(nums[1], c, ans);
          deal<4 & 4>(nums[2], c, ans);
          deal<4 & 8>(nums[3], c, ans);
          deal<4 & 16>(nums[4], c, ans);
          deal<4 & 32>(nums[5], c, ans);
          deal<4 & 64>(nums[6], c, ans);
          deal<4 & 128>(nums[7], c, ans);
          break;
        };
        case 5: {
          deal<5 & 1>(nums[0], c, ans);
          deal<5 & 2>(nums[1], c, ans);
          deal<5 & 4>(nums[2], c, ans);
          deal<5 & 8>(nums[3], c, ans);
          deal<5 & 16>(nums[4], c, ans);
          deal<5 & 32>(nums[5], c, ans);
          deal<5 & 64>(nums[6], c, ans);
          deal<5 & 128>(nums[7], c, ans);
          break;
        };
        case 6: {
          deal<6 & 1>(nums[0], c, ans);
          deal<6 & 2>(nums[1], c, ans);
          deal<6 & 4>(nums[2], c, ans);
          deal<6 & 8>(nums[3], c, ans);
          deal<6 & 16>(nums[4], c, ans);
          deal<6 & 32>(nums[5], c, ans);
          deal<6 & 64>(nums[6], c, ans);
          deal<6 & 128>(nums[7], c, ans);
          break;
        };
        case 7: {
          deal<7 & 1>(nums[0], c, ans);
          deal<7 & 2>(nums[1], c, ans);
          deal<7 & 4>(nums[2], c, ans);
          deal<7 & 8>(nums[3], c, ans);
          deal<7 & 16>(nums[4], c, ans);
          deal<7 & 32>(nums[5], c, ans);
          deal<7 & 64>(nums[6], c, ans);
          deal<7 & 128>(nums[7], c, ans);
          break;
        };
        case 8: {
          deal<8 & 1>(nums[0], c, ans);
          deal<8 & 2>(nums[1], c, ans);
          deal<8 & 4>(nums[2], c, ans);
          deal<8 & 8>(nums[3], c, ans);
          deal<8 & 16>(nums[4], c, ans);
          deal<8 & 32>(nums[5], c, ans);
          deal<8 & 64>(nums[6], c, ans);
          deal<8 & 128>(nums[7], c, ans);
          break;
        };
        case 9: {
          deal<9 & 1>(nums[0], c, ans);
          deal<9 & 2>(nums[1], c, ans);
          deal<9 & 4>(nums[2], c, ans);
          deal<9 & 8>(nums[3], c, ans);
          deal<9 & 16>(nums[4], c, ans);
          deal<9 & 32>(nums[5], c, ans);
          deal<9 & 64>(nums[6], c, ans);
          deal<9 & 128>(nums[7], c, ans);
          break;
        };
        case 10: {
          deal<10 & 1>(nums[0], c, ans);
          deal<10 & 2>(nums[1], c, ans);
          deal<10 & 4>(nums[2], c, ans);
          deal<10 & 8>(nums[3], c, ans);
          deal<10 & 16>(nums[4], c, ans);
          deal<10 & 32>(nums[5], c, ans);
          deal<10 & 64>(nums[6], c, ans);
          deal<10 & 128>(nums[7], c, ans);
          break;
        };
        case 11: {
          deal<11 & 1>(nums[0], c, ans);
          deal<11 & 2>(nums[1], c, ans);
          deal<11 & 4>(nums[2], c, ans);
          deal<11 & 8>(nums[3], c, ans);
          deal<11 & 16>(nums[4], c, ans);
          deal<11 & 32>(nums[5], c, ans);
          deal<11 & 64>(nums[6], c, ans);
          deal<11 & 128>(nums[7], c, ans);
          break;
        };
        case 12: {
          deal<12 & 1>(nums[0], c, ans);
          deal<12 & 2>(nums[1], c, ans);
          deal<12 & 4>(nums[2], c, ans);
          deal<12 & 8>(nums[3], c, ans);
          deal<12 & 16>(nums[4], c, ans);
          deal<12 & 32>(nums[5], c, ans);
          deal<12 & 64>(nums[6], c, ans);
          deal<12 & 128>(nums[7], c, ans);
          break;
        };
        case 13: {
          deal<13 & 1>(nums[0], c, ans);
          deal<13 & 2>(nums[1], c, ans);
          deal<13 & 4>(nums[2], c, ans);
          deal<13 & 8>(nums[3], c, ans);
          deal<13 & 16>(nums[4], c, ans);
          deal<13 & 32>(nums[5], c, ans);
          deal<13 & 64>(nums[6], c, ans);
          deal<13 & 128>(nums[7], c, ans);
          break;
        };
        case 14: {
          deal<14 & 1>(nums[0], c, ans);
          deal<14 & 2>(nums[1], c, ans);
          deal<14 & 4>(nums[2], c, ans);
          deal<14 & 8>(nums[3], c, ans);
          deal<14 & 16>(nums[4], c, ans);
          deal<14 & 32>(nums[5], c, ans);
          deal<14 & 64>(nums[6], c, ans);
          deal<14 & 128>(nums[7], c, ans);
          break;
        };
        case 15: {
          deal<15 & 1>(nums[0], c, ans);
          deal<15 & 2>(nums[1], c, ans);
          deal<15 & 4>(nums[2], c, ans);
          deal<15 & 8>(nums[3], c, ans);
          deal<15 & 16>(nums[4], c, ans);
          deal<15 & 32>(nums[5], c, ans);
          deal<15 & 64>(nums[6], c, ans);
          deal<15 & 128>(nums[7], c, ans);
          break;
        };
        case 16: {
          deal<16 & 1>(nums[0], c, ans);
          deal<16 & 2>(nums[1], c, ans);
          deal<16 & 4>(nums[2], c, ans);
          deal<16 & 8>(nums[3], c, ans);
          deal<16 & 16>(nums[4], c, ans);
          deal<16 & 32>(nums[5], c, ans);
          deal<16 & 64>(nums[6], c, ans);
          deal<16 & 128>(nums[7], c, ans);
          break;
        };
        case 17: {
          deal<17 & 1>(nums[0], c, ans);
          deal<17 & 2>(nums[1], c, ans);
          deal<17 & 4>(nums[2], c, ans);
          deal<17 & 8>(nums[3], c, ans);
          deal<17 & 16>(nums[4], c, ans);
          deal<17 & 32>(nums[5], c, ans);
          deal<17 & 64>(nums[6], c, ans);
          deal<17 & 128>(nums[7], c, ans);
          break;
        };
        case 18: {
          deal<18 & 1>(nums[0], c, ans);
          deal<18 & 2>(nums[1], c, ans);
          deal<18 & 4>(nums[2], c, ans);
          deal<18 & 8>(nums[3], c, ans);
          deal<18 & 16>(nums[4], c, ans);
          deal<18 & 32>(nums[5], c, ans);
          deal<18 & 64>(nums[6], c, ans);
          deal<18 & 128>(nums[7], c, ans);
          break;
        };
        case 19: {
          deal<19 & 1>(nums[0], c, ans);
          deal<19 & 2>(nums[1], c, ans);
          deal<19 & 4>(nums[2], c, ans);
          deal<19 & 8>(nums[3], c, ans);
          deal<19 & 16>(nums[4], c, ans);
          deal<19 & 32>(nums[5], c, ans);
          deal<19 & 64>(nums[6], c, ans);
          deal<19 & 128>(nums[7], c, ans);
          break;
        };
        case 20: {
          deal<20 & 1>(nums[0], c, ans);
          deal<20 & 2>(nums[1], c, ans);
          deal<20 & 4>(nums[2], c, ans);
          deal<20 & 8>(nums[3], c, ans);
          deal<20 & 16>(nums[4], c, ans);
          deal<20 & 32>(nums[5], c, ans);
          deal<20 & 64>(nums[6], c, ans);
          deal<20 & 128>(nums[7], c, ans);
          break;
        };
        case 21: {
          deal<21 & 1>(nums[0], c, ans);
          deal<21 & 2>(nums[1], c, ans);
          deal<21 & 4>(nums[2], c, ans);
          deal<21 & 8>(nums[3], c, ans);
          deal<21 & 16>(nums[4], c, ans);
          deal<21 & 32>(nums[5], c, ans);
          deal<21 & 64>(nums[6], c, ans);
          deal<21 & 128>(nums[7], c, ans);
          break;
        };
        case 22: {
          deal<22 & 1>(nums[0], c, ans);
          deal<22 & 2>(nums[1], c, ans);
          deal<22 & 4>(nums[2], c, ans);
          deal<22 & 8>(nums[3], c, ans);
          deal<22 & 16>(nums[4], c, ans);
          deal<22 & 32>(nums[5], c, ans);
          deal<22 & 64>(nums[6], c, ans);
          deal<22 & 128>(nums[7], c, ans);
          break;
        };
        case 23: {
          deal<23 & 1>(nums[0], c, ans);
          deal<23 & 2>(nums[1], c, ans);
          deal<23 & 4>(nums[2], c, ans);
          deal<23 & 8>(nums[3], c, ans);
          deal<23 & 16>(nums[4], c, ans);
          deal<23 & 32>(nums[5], c, ans);
          deal<23 & 64>(nums[6], c, ans);
          deal<23 & 128>(nums[7], c, ans);
          break;
        };
        case 24: {
          deal<24 & 1>(nums[0], c, ans);
          deal<24 & 2>(nums[1], c, ans);
          deal<24 & 4>(nums[2], c, ans);
          deal<24 & 8>(nums[3], c, ans);
          deal<24 & 16>(nums[4], c, ans);
          deal<24 & 32>(nums[5], c, ans);
          deal<24 & 64>(nums[6], c, ans);
          deal<24 & 128>(nums[7], c, ans);
          break;
        };
        case 25: {
          deal<25 & 1>(nums[0], c, ans);
          deal<25 & 2>(nums[1], c, ans);
          deal<25 & 4>(nums[2], c, ans);
          deal<25 & 8>(nums[3], c, ans);
          deal<25 & 16>(nums[4], c, ans);
          deal<25 & 32>(nums[5], c, ans);
          deal<25 & 64>(nums[6], c, ans);
          deal<25 & 128>(nums[7], c, ans);
          break;
        };
        case 26: {
          deal<26 & 1>(nums[0], c, ans);
          deal<26 & 2>(nums[1], c, ans);
          deal<26 & 4>(nums[2], c, ans);
          deal<26 & 8>(nums[3], c, ans);
          deal<26 & 16>(nums[4], c, ans);
          deal<26 & 32>(nums[5], c, ans);
          deal<26 & 64>(nums[6], c, ans);
          deal<26 & 128>(nums[7], c, ans);
          break;
        };
        case 27: {
          deal<27 & 1>(nums[0], c, ans);
          deal<27 & 2>(nums[1], c, ans);
          deal<27 & 4>(nums[2], c, ans);
          deal<27 & 8>(nums[3], c, ans);
          deal<27 & 16>(nums[4], c, ans);
          deal<27 & 32>(nums[5], c, ans);
          deal<27 & 64>(nums[6], c, ans);
          deal<27 & 128>(nums[7], c, ans);
          break;
        };
        case 28: {
          deal<28 & 1>(nums[0], c, ans);
          deal<28 & 2>(nums[1], c, ans);
          deal<28 & 4>(nums[2], c, ans);
          deal<28 & 8>(nums[3], c, ans);
          deal<28 & 16>(nums[4], c, ans);
          deal<28 & 32>(nums[5], c, ans);
          deal<28 & 64>(nums[6], c, ans);
          deal<28 & 128>(nums[7], c, ans);
          break;
        };
        case 29: {
          deal<29 & 1>(nums[0], c, ans);
          deal<29 & 2>(nums[1], c, ans);
          deal<29 & 4>(nums[2], c, ans);
          deal<29 & 8>(nums[3], c, ans);
          deal<29 & 16>(nums[4], c, ans);
          deal<29 & 32>(nums[5], c, ans);
          deal<29 & 64>(nums[6], c, ans);
          deal<29 & 128>(nums[7], c, ans);
          break;
        };
        case 30: {
          deal<30 & 1>(nums[0], c, ans);
          deal<30 & 2>(nums[1], c, ans);
          deal<30 & 4>(nums[2], c, ans);
          deal<30 & 8>(nums[3], c, ans);
          deal<30 & 16>(nums[4], c, ans);
          deal<30 & 32>(nums[5], c, ans);
          deal<30 & 64>(nums[6], c, ans);
          deal<30 & 128>(nums[7], c, ans);
          break;
        };
        case 31: {
          deal<31 & 1>(nums[0], c, ans);
          deal<31 & 2>(nums[1], c, ans);
          deal<31 & 4>(nums[2], c, ans);
          deal<31 & 8>(nums[3], c, ans);
          deal<31 & 16>(nums[4], c, ans);
          deal<31 & 32>(nums[5], c, ans);
          deal<31 & 64>(nums[6], c, ans);
          deal<31 & 128>(nums[7], c, ans);
          break;
        };
        case 32: {
          deal<32 & 1>(nums[0], c, ans);
          deal<32 & 2>(nums[1], c, ans);
          deal<32 & 4>(nums[2], c, ans);
          deal<32 & 8>(nums[3], c, ans);
          deal<32 & 16>(nums[4], c, ans);
          deal<32 & 32>(nums[5], c, ans);
          deal<32 & 64>(nums[6], c, ans);
          deal<32 & 128>(nums[7], c, ans);
          break;
        };
        case 33: {
          deal<33 & 1>(nums[0], c, ans);
          deal<33 & 2>(nums[1], c, ans);
          deal<33 & 4>(nums[2], c, ans);
          deal<33 & 8>(nums[3], c, ans);
          deal<33 & 16>(nums[4], c, ans);
          deal<33 & 32>(nums[5], c, ans);
          deal<33 & 64>(nums[6], c, ans);
          deal<33 & 128>(nums[7], c, ans);
          break;
        };
        case 34: {
          deal<34 & 1>(nums[0], c, ans);
          deal<34 & 2>(nums[1], c, ans);
          deal<34 & 4>(nums[2], c, ans);
          deal<34 & 8>(nums[3], c, ans);
          deal<34 & 16>(nums[4], c, ans);
          deal<34 & 32>(nums[5], c, ans);
          deal<34 & 64>(nums[6], c, ans);
          deal<34 & 128>(nums[7], c, ans);
          break;
        };
        case 35: {
          deal<35 & 1>(nums[0], c, ans);
          deal<35 & 2>(nums[1], c, ans);
          deal<35 & 4>(nums[2], c, ans);
          deal<35 & 8>(nums[3], c, ans);
          deal<35 & 16>(nums[4], c, ans);
          deal<35 & 32>(nums[5], c, ans);
          deal<35 & 64>(nums[6], c, ans);
          deal<35 & 128>(nums[7], c, ans);
          break;
        };
        case 36: {
          deal<36 & 1>(nums[0], c, ans);
          deal<36 & 2>(nums[1], c, ans);
          deal<36 & 4>(nums[2], c, ans);
          deal<36 & 8>(nums[3], c, ans);
          deal<36 & 16>(nums[4], c, ans);
          deal<36 & 32>(nums[5], c, ans);
          deal<36 & 64>(nums[6], c, ans);
          deal<36 & 128>(nums[7], c, ans);
          break;
        };
        case 37: {
          deal<37 & 1>(nums[0], c, ans);
          deal<37 & 2>(nums[1], c, ans);
          deal<37 & 4>(nums[2], c, ans);
          deal<37 & 8>(nums[3], c, ans);
          deal<37 & 16>(nums[4], c, ans);
          deal<37 & 32>(nums[5], c, ans);
          deal<37 & 64>(nums[6], c, ans);
          deal<37 & 128>(nums[7], c, ans);
          break;
        };
        case 38: {
          deal<38 & 1>(nums[0], c, ans);
          deal<38 & 2>(nums[1], c, ans);
          deal<38 & 4>(nums[2], c, ans);
          deal<38 & 8>(nums[3], c, ans);
          deal<38 & 16>(nums[4], c, ans);
          deal<38 & 32>(nums[5], c, ans);
          deal<38 & 64>(nums[6], c, ans);
          deal<38 & 128>(nums[7], c, ans);
          break;
        };
        case 39: {
          deal<39 & 1>(nums[0], c, ans);
          deal<39 & 2>(nums[1], c, ans);
          deal<39 & 4>(nums[2], c, ans);
          deal<39 & 8>(nums[3], c, ans);
          deal<39 & 16>(nums[4], c, ans);
          deal<39 & 32>(nums[5], c, ans);
          deal<39 & 64>(nums[6], c, ans);
          deal<39 & 128>(nums[7], c, ans);
          break;
        };
        case 40: {
          deal<40 & 1>(nums[0], c, ans);
          deal<40 & 2>(nums[1], c, ans);
          deal<40 & 4>(nums[2], c, ans);
          deal<40 & 8>(nums[3], c, ans);
          deal<40 & 16>(nums[4], c, ans);
          deal<40 & 32>(nums[5], c, ans);
          deal<40 & 64>(nums[6], c, ans);
          deal<40 & 128>(nums[7], c, ans);
          break;
        };
        case 41: {
          deal<41 & 1>(nums[0], c, ans);
          deal<41 & 2>(nums[1], c, ans);
          deal<41 & 4>(nums[2], c, ans);
          deal<41 & 8>(nums[3], c, ans);
          deal<41 & 16>(nums[4], c, ans);
          deal<41 & 32>(nums[5], c, ans);
          deal<41 & 64>(nums[6], c, ans);
          deal<41 & 128>(nums[7], c, ans);
          break;
        };
        case 42: {
          deal<42 & 1>(nums[0], c, ans);
          deal<42 & 2>(nums[1], c, ans);
          deal<42 & 4>(nums[2], c, ans);
          deal<42 & 8>(nums[3], c, ans);
          deal<42 & 16>(nums[4], c, ans);
          deal<42 & 32>(nums[5], c, ans);
          deal<42 & 64>(nums[6], c, ans);
          deal<42 & 128>(nums[7], c, ans);
          break;
        };
        case 43: {
          deal<43 & 1>(nums[0], c, ans);
          deal<43 & 2>(nums[1], c, ans);
          deal<43 & 4>(nums[2], c, ans);
          deal<43 & 8>(nums[3], c, ans);
          deal<43 & 16>(nums[4], c, ans);
          deal<43 & 32>(nums[5], c, ans);
          deal<43 & 64>(nums[6], c, ans);
          deal<43 & 128>(nums[7], c, ans);
          break;
        };
        case 44: {
          deal<44 & 1>(nums[0], c, ans);
          deal<44 & 2>(nums[1], c, ans);
          deal<44 & 4>(nums[2], c, ans);
          deal<44 & 8>(nums[3], c, ans);
          deal<44 & 16>(nums[4], c, ans);
          deal<44 & 32>(nums[5], c, ans);
          deal<44 & 64>(nums[6], c, ans);
          deal<44 & 128>(nums[7], c, ans);
          break;
        };
        case 45: {
          deal<45 & 1>(nums[0], c, ans);
          deal<45 & 2>(nums[1], c, ans);
          deal<45 & 4>(nums[2], c, ans);
          deal<45 & 8>(nums[3], c, ans);
          deal<45 & 16>(nums[4], c, ans);
          deal<45 & 32>(nums[5], c, ans);
          deal<45 & 64>(nums[6], c, ans);
          deal<45 & 128>(nums[7], c, ans);
          break;
        };
        case 46: {
          deal<46 & 1>(nums[0], c, ans);
          deal<46 & 2>(nums[1], c, ans);
          deal<46 & 4>(nums[2], c, ans);
          deal<46 & 8>(nums[3], c, ans);
          deal<46 & 16>(nums[4], c, ans);
          deal<46 & 32>(nums[5], c, ans);
          deal<46 & 64>(nums[6], c, ans);
          deal<46 & 128>(nums[7], c, ans);
          break;
        };
        case 47: {
          deal<47 & 1>(nums[0], c, ans);
          deal<47 & 2>(nums[1], c, ans);
          deal<47 & 4>(nums[2], c, ans);
          deal<47 & 8>(nums[3], c, ans);
          deal<47 & 16>(nums[4], c, ans);
          deal<47 & 32>(nums[5], c, ans);
          deal<47 & 64>(nums[6], c, ans);
          deal<47 & 128>(nums[7], c, ans);
          break;
        };
        case 48: {
          deal<48 & 1>(nums[0], c, ans);
          deal<48 & 2>(nums[1], c, ans);
          deal<48 & 4>(nums[2], c, ans);
          deal<48 & 8>(nums[3], c, ans);
          deal<48 & 16>(nums[4], c, ans);
          deal<48 & 32>(nums[5], c, ans);
          deal<48 & 64>(nums[6], c, ans);
          deal<48 & 128>(nums[7], c, ans);
          break;
        };
        case 49: {
          deal<49 & 1>(nums[0], c, ans);
          deal<49 & 2>(nums[1], c, ans);
          deal<49 & 4>(nums[2], c, ans);
          deal<49 & 8>(nums[3], c, ans);
          deal<49 & 16>(nums[4], c, ans);
          deal<49 & 32>(nums[5], c, ans);
          deal<49 & 64>(nums[6], c, ans);
          deal<49 & 128>(nums[7], c, ans);
          break;
        };
        case 50: {
          deal<50 & 1>(nums[0], c, ans);
          deal<50 & 2>(nums[1], c, ans);
          deal<50 & 4>(nums[2], c, ans);
          deal<50 & 8>(nums[3], c, ans);
          deal<50 & 16>(nums[4], c, ans);
          deal<50 & 32>(nums[5], c, ans);
          deal<50 & 64>(nums[6], c, ans);
          deal<50 & 128>(nums[7], c, ans);
          break;
        };
        case 51: {
          deal<51 & 1>(nums[0], c, ans);
          deal<51 & 2>(nums[1], c, ans);
          deal<51 & 4>(nums[2], c, ans);
          deal<51 & 8>(nums[3], c, ans);
          deal<51 & 16>(nums[4], c, ans);
          deal<51 & 32>(nums[5], c, ans);
          deal<51 & 64>(nums[6], c, ans);
          deal<51 & 128>(nums[7], c, ans);
          break;
        };
        case 52: {
          deal<52 & 1>(nums[0], c, ans);
          deal<52 & 2>(nums[1], c, ans);
          deal<52 & 4>(nums[2], c, ans);
          deal<52 & 8>(nums[3], c, ans);
          deal<52 & 16>(nums[4], c, ans);
          deal<52 & 32>(nums[5], c, ans);
          deal<52 & 64>(nums[6], c, ans);
          deal<52 & 128>(nums[7], c, ans);
          break;
        };
        case 53: {
          deal<53 & 1>(nums[0], c, ans);
          deal<53 & 2>(nums[1], c, ans);
          deal<53 & 4>(nums[2], c, ans);
          deal<53 & 8>(nums[3], c, ans);
          deal<53 & 16>(nums[4], c, ans);
          deal<53 & 32>(nums[5], c, ans);
          deal<53 & 64>(nums[6], c, ans);
          deal<53 & 128>(nums[7], c, ans);
          break;
        };
        case 54: {
          deal<54 & 1>(nums[0], c, ans);
          deal<54 & 2>(nums[1], c, ans);
          deal<54 & 4>(nums[2], c, ans);
          deal<54 & 8>(nums[3], c, ans);
          deal<54 & 16>(nums[4], c, ans);
          deal<54 & 32>(nums[5], c, ans);
          deal<54 & 64>(nums[6], c, ans);
          deal<54 & 128>(nums[7], c, ans);
          break;
        };
        case 55: {
          deal<55 & 1>(nums[0], c, ans);
          deal<55 & 2>(nums[1], c, ans);
          deal<55 & 4>(nums[2], c, ans);
          deal<55 & 8>(nums[3], c, ans);
          deal<55 & 16>(nums[4], c, ans);
          deal<55 & 32>(nums[5], c, ans);
          deal<55 & 64>(nums[6], c, ans);
          deal<55 & 128>(nums[7], c, ans);
          break;
        };
        case 56: {
          deal<56 & 1>(nums[0], c, ans);
          deal<56 & 2>(nums[1], c, ans);
          deal<56 & 4>(nums[2], c, ans);
          deal<56 & 8>(nums[3], c, ans);
          deal<56 & 16>(nums[4], c, ans);
          deal<56 & 32>(nums[5], c, ans);
          deal<56 & 64>(nums[6], c, ans);
          deal<56 & 128>(nums[7], c, ans);
          break;
        };
        case 57: {
          deal<57 & 1>(nums[0], c, ans);
          deal<57 & 2>(nums[1], c, ans);
          deal<57 & 4>(nums[2], c, ans);
          deal<57 & 8>(nums[3], c, ans);
          deal<57 & 16>(nums[4], c, ans);
          deal<57 & 32>(nums[5], c, ans);
          deal<57 & 64>(nums[6], c, ans);
          deal<57 & 128>(nums[7], c, ans);
          break;
        };
        case 58: {
          deal<58 & 1>(nums[0], c, ans);
          deal<58 & 2>(nums[1], c, ans);
          deal<58 & 4>(nums[2], c, ans);
          deal<58 & 8>(nums[3], c, ans);
          deal<58 & 16>(nums[4], c, ans);
          deal<58 & 32>(nums[5], c, ans);
          deal<58 & 64>(nums[6], c, ans);
          deal<58 & 128>(nums[7], c, ans);
          break;
        };
        case 59: {
          deal<59 & 1>(nums[0], c, ans);
          deal<59 & 2>(nums[1], c, ans);
          deal<59 & 4>(nums[2], c, ans);
          deal<59 & 8>(nums[3], c, ans);
          deal<59 & 16>(nums[4], c, ans);
          deal<59 & 32>(nums[5], c, ans);
          deal<59 & 64>(nums[6], c, ans);
          deal<59 & 128>(nums[7], c, ans);
          break;
        };
        case 60: {
          deal<60 & 1>(nums[0], c, ans);
          deal<60 & 2>(nums[1], c, ans);
          deal<60 & 4>(nums[2], c, ans);
          deal<60 & 8>(nums[3], c, ans);
          deal<60 & 16>(nums[4], c, ans);
          deal<60 & 32>(nums[5], c, ans);
          deal<60 & 64>(nums[6], c, ans);
          deal<60 & 128>(nums[7], c, ans);
          break;
        };
        case 61: {
          deal<61 & 1>(nums[0], c, ans);
          deal<61 & 2>(nums[1], c, ans);
          deal<61 & 4>(nums[2], c, ans);
          deal<61 & 8>(nums[3], c, ans);
          deal<61 & 16>(nums[4], c, ans);
          deal<61 & 32>(nums[5], c, ans);
          deal<61 & 64>(nums[6], c, ans);
          deal<61 & 128>(nums[7], c, ans);
          break;
        };
        case 62: {
          deal<62 & 1>(nums[0], c, ans);
          deal<62 & 2>(nums[1], c, ans);
          deal<62 & 4>(nums[2], c, ans);
          deal<62 & 8>(nums[3], c, ans);
          deal<62 & 16>(nums[4], c, ans);
          deal<62 & 32>(nums[5], c, ans);
          deal<62 & 64>(nums[6], c, ans);
          deal<62 & 128>(nums[7], c, ans);
          break;
        };
        case 63: {
          deal<63 & 1>(nums[0], c, ans);
          deal<63 & 2>(nums[1], c, ans);
          deal<63 & 4>(nums[2], c, ans);
          deal<63 & 8>(nums[3], c, ans);
          deal<63 & 16>(nums[4], c, ans);
          deal<63 & 32>(nums[5], c, ans);
          deal<63 & 64>(nums[6], c, ans);
          deal<63 & 128>(nums[7], c, ans);
          break;
        };
        case 64: {
          deal<64 & 1>(nums[0], c, ans);
          deal<64 & 2>(nums[1], c, ans);
          deal<64 & 4>(nums[2], c, ans);
          deal<64 & 8>(nums[3], c, ans);
          deal<64 & 16>(nums[4], c, ans);
          deal<64 & 32>(nums[5], c, ans);
          deal<64 & 64>(nums[6], c, ans);
          deal<64 & 128>(nums[7], c, ans);
          break;
        };
        case 65: {
          deal<65 & 1>(nums[0], c, ans);
          deal<65 & 2>(nums[1], c, ans);
          deal<65 & 4>(nums[2], c, ans);
          deal<65 & 8>(nums[3], c, ans);
          deal<65 & 16>(nums[4], c, ans);
          deal<65 & 32>(nums[5], c, ans);
          deal<65 & 64>(nums[6], c, ans);
          deal<65 & 128>(nums[7], c, ans);
          break;
        };
        case 66: {
          deal<66 & 1>(nums[0], c, ans);
          deal<66 & 2>(nums[1], c, ans);
          deal<66 & 4>(nums[2], c, ans);
          deal<66 & 8>(nums[3], c, ans);
          deal<66 & 16>(nums[4], c, ans);
          deal<66 & 32>(nums[5], c, ans);
          deal<66 & 64>(nums[6], c, ans);
          deal<66 & 128>(nums[7], c, ans);
          break;
        };
        case 67: {
          deal<67 & 1>(nums[0], c, ans);
          deal<67 & 2>(nums[1], c, ans);
          deal<67 & 4>(nums[2], c, ans);
          deal<67 & 8>(nums[3], c, ans);
          deal<67 & 16>(nums[4], c, ans);
          deal<67 & 32>(nums[5], c, ans);
          deal<67 & 64>(nums[6], c, ans);
          deal<67 & 128>(nums[7], c, ans);
          break;
        };
        case 68: {
          deal<68 & 1>(nums[0], c, ans);
          deal<68 & 2>(nums[1], c, ans);
          deal<68 & 4>(nums[2], c, ans);
          deal<68 & 8>(nums[3], c, ans);
          deal<68 & 16>(nums[4], c, ans);
          deal<68 & 32>(nums[5], c, ans);
          deal<68 & 64>(nums[6], c, ans);
          deal<68 & 128>(nums[7], c, ans);
          break;
        };
        case 69: {
          deal<69 & 1>(nums[0], c, ans);
          deal<69 & 2>(nums[1], c, ans);
          deal<69 & 4>(nums[2], c, ans);
          deal<69 & 8>(nums[3], c, ans);
          deal<69 & 16>(nums[4], c, ans);
          deal<69 & 32>(nums[5], c, ans);
          deal<69 & 64>(nums[6], c, ans);
          deal<69 & 128>(nums[7], c, ans);
          break;
        };
        case 70: {
          deal<70 & 1>(nums[0], c, ans);
          deal<70 & 2>(nums[1], c, ans);
          deal<70 & 4>(nums[2], c, ans);
          deal<70 & 8>(nums[3], c, ans);
          deal<70 & 16>(nums[4], c, ans);
          deal<70 & 32>(nums[5], c, ans);
          deal<70 & 64>(nums[6], c, ans);
          deal<70 & 128>(nums[7], c, ans);
          break;
        };
        case 71: {
          deal<71 & 1>(nums[0], c, ans);
          deal<71 & 2>(nums[1], c, ans);
          deal<71 & 4>(nums[2], c, ans);
          deal<71 & 8>(nums[3], c, ans);
          deal<71 & 16>(nums[4], c, ans);
          deal<71 & 32>(nums[5], c, ans);
          deal<71 & 64>(nums[6], c, ans);
          deal<71 & 128>(nums[7], c, ans);
          break;
        };
        case 72: {
          deal<72 & 1>(nums[0], c, ans);
          deal<72 & 2>(nums[1], c, ans);
          deal<72 & 4>(nums[2], c, ans);
          deal<72 & 8>(nums[3], c, ans);
          deal<72 & 16>(nums[4], c, ans);
          deal<72 & 32>(nums[5], c, ans);
          deal<72 & 64>(nums[6], c, ans);
          deal<72 & 128>(nums[7], c, ans);
          break;
        };
        case 73: {
          deal<73 & 1>(nums[0], c, ans);
          deal<73 & 2>(nums[1], c, ans);
          deal<73 & 4>(nums[2], c, ans);
          deal<73 & 8>(nums[3], c, ans);
          deal<73 & 16>(nums[4], c, ans);
          deal<73 & 32>(nums[5], c, ans);
          deal<73 & 64>(nums[6], c, ans);
          deal<73 & 128>(nums[7], c, ans);
          break;
        };
        case 74: {
          deal<74 & 1>(nums[0], c, ans);
          deal<74 & 2>(nums[1], c, ans);
          deal<74 & 4>(nums[2], c, ans);
          deal<74 & 8>(nums[3], c, ans);
          deal<74 & 16>(nums[4], c, ans);
          deal<74 & 32>(nums[5], c, ans);
          deal<74 & 64>(nums[6], c, ans);
          deal<74 & 128>(nums[7], c, ans);
          break;
        };
        case 75: {
          deal<75 & 1>(nums[0], c, ans);
          deal<75 & 2>(nums[1], c, ans);
          deal<75 & 4>(nums[2], c, ans);
          deal<75 & 8>(nums[3], c, ans);
          deal<75 & 16>(nums[4], c, ans);
          deal<75 & 32>(nums[5], c, ans);
          deal<75 & 64>(nums[6], c, ans);
          deal<75 & 128>(nums[7], c, ans);
          break;
        };
        case 76: {
          deal<76 & 1>(nums[0], c, ans);
          deal<76 & 2>(nums[1], c, ans);
          deal<76 & 4>(nums[2], c, ans);
          deal<76 & 8>(nums[3], c, ans);
          deal<76 & 16>(nums[4], c, ans);
          deal<76 & 32>(nums[5], c, ans);
          deal<76 & 64>(nums[6], c, ans);
          deal<76 & 128>(nums[7], c, ans);
          break;
        };
        case 77: {
          deal<77 & 1>(nums[0], c, ans);
          deal<77 & 2>(nums[1], c, ans);
          deal<77 & 4>(nums[2], c, ans);
          deal<77 & 8>(nums[3], c, ans);
          deal<77 & 16>(nums[4], c, ans);
          deal<77 & 32>(nums[5], c, ans);
          deal<77 & 64>(nums[6], c, ans);
          deal<77 & 128>(nums[7], c, ans);
          break;
        };
        case 78: {
          deal<78 & 1>(nums[0], c, ans);
          deal<78 & 2>(nums[1], c, ans);
          deal<78 & 4>(nums[2], c, ans);
          deal<78 & 8>(nums[3], c, ans);
          deal<78 & 16>(nums[4], c, ans);
          deal<78 & 32>(nums[5], c, ans);
          deal<78 & 64>(nums[6], c, ans);
          deal<78 & 128>(nums[7], c, ans);
          break;
        };
        case 79: {
          deal<79 & 1>(nums[0], c, ans);
          deal<79 & 2>(nums[1], c, ans);
          deal<79 & 4>(nums[2], c, ans);
          deal<79 & 8>(nums[3], c, ans);
          deal<79 & 16>(nums[4], c, ans);
          deal<79 & 32>(nums[5], c, ans);
          deal<79 & 64>(nums[6], c, ans);
          deal<79 & 128>(nums[7], c, ans);
          break;
        };
        case 80: {
          deal<80 & 1>(nums[0], c, ans);
          deal<80 & 2>(nums[1], c, ans);
          deal<80 & 4>(nums[2], c, ans);
          deal<80 & 8>(nums[3], c, ans);
          deal<80 & 16>(nums[4], c, ans);
          deal<80 & 32>(nums[5], c, ans);
          deal<80 & 64>(nums[6], c, ans);
          deal<80 & 128>(nums[7], c, ans);
          break;
        };
        case 81: {
          deal<81 & 1>(nums[0], c, ans);
          deal<81 & 2>(nums[1], c, ans);
          deal<81 & 4>(nums[2], c, ans);
          deal<81 & 8>(nums[3], c, ans);
          deal<81 & 16>(nums[4], c, ans);
          deal<81 & 32>(nums[5], c, ans);
          deal<81 & 64>(nums[6], c, ans);
          deal<81 & 128>(nums[7], c, ans);
          break;
        };
        case 82: {
          deal<82 & 1>(nums[0], c, ans);
          deal<82 & 2>(nums[1], c, ans);
          deal<82 & 4>(nums[2], c, ans);
          deal<82 & 8>(nums[3], c, ans);
          deal<82 & 16>(nums[4], c, ans);
          deal<82 & 32>(nums[5], c, ans);
          deal<82 & 64>(nums[6], c, ans);
          deal<82 & 128>(nums[7], c, ans);
          break;
        };
        case 83: {
          deal<83 & 1>(nums[0], c, ans);
          deal<83 & 2>(nums[1], c, ans);
          deal<83 & 4>(nums[2], c, ans);
          deal<83 & 8>(nums[3], c, ans);
          deal<83 & 16>(nums[4], c, ans);
          deal<83 & 32>(nums[5], c, ans);
          deal<83 & 64>(nums[6], c, ans);
          deal<83 & 128>(nums[7], c, ans);
          break;
        };
        case 84: {
          deal<84 & 1>(nums[0], c, ans);
          deal<84 & 2>(nums[1], c, ans);
          deal<84 & 4>(nums[2], c, ans);
          deal<84 & 8>(nums[3], c, ans);
          deal<84 & 16>(nums[4], c, ans);
          deal<84 & 32>(nums[5], c, ans);
          deal<84 & 64>(nums[6], c, ans);
          deal<84 & 128>(nums[7], c, ans);
          break;
        };
        case 85: {
          deal<85 & 1>(nums[0], c, ans);
          deal<85 & 2>(nums[1], c, ans);
          deal<85 & 4>(nums[2], c, ans);
          deal<85 & 8>(nums[3], c, ans);
          deal<85 & 16>(nums[4], c, ans);
          deal<85 & 32>(nums[5], c, ans);
          deal<85 & 64>(nums[6], c, ans);
          deal<85 & 128>(nums[7], c, ans);
          break;
        };
        case 86: {
          deal<86 & 1>(nums[0], c, ans);
          deal<86 & 2>(nums[1], c, ans);
          deal<86 & 4>(nums[2], c, ans);
          deal<86 & 8>(nums[3], c, ans);
          deal<86 & 16>(nums[4], c, ans);
          deal<86 & 32>(nums[5], c, ans);
          deal<86 & 64>(nums[6], c, ans);
          deal<86 & 128>(nums[7], c, ans);
          break;
        };
        case 87: {
          deal<87 & 1>(nums[0], c, ans);
          deal<87 & 2>(nums[1], c, ans);
          deal<87 & 4>(nums[2], c, ans);
          deal<87 & 8>(nums[3], c, ans);
          deal<87 & 16>(nums[4], c, ans);
          deal<87 & 32>(nums[5], c, ans);
          deal<87 & 64>(nums[6], c, ans);
          deal<87 & 128>(nums[7], c, ans);
          break;
        };
        case 88: {
          deal<88 & 1>(nums[0], c, ans);
          deal<88 & 2>(nums[1], c, ans);
          deal<88 & 4>(nums[2], c, ans);
          deal<88 & 8>(nums[3], c, ans);
          deal<88 & 16>(nums[4], c, ans);
          deal<88 & 32>(nums[5], c, ans);
          deal<88 & 64>(nums[6], c, ans);
          deal<88 & 128>(nums[7], c, ans);
          break;
        };
        case 89: {
          deal<89 & 1>(nums[0], c, ans);
          deal<89 & 2>(nums[1], c, ans);
          deal<89 & 4>(nums[2], c, ans);
          deal<89 & 8>(nums[3], c, ans);
          deal<89 & 16>(nums[4], c, ans);
          deal<89 & 32>(nums[5], c, ans);
          deal<89 & 64>(nums[6], c, ans);
          deal<89 & 128>(nums[7], c, ans);
          break;
        };
        case 90: {
          deal<90 & 1>(nums[0], c, ans);
          deal<90 & 2>(nums[1], c, ans);
          deal<90 & 4>(nums[2], c, ans);
          deal<90 & 8>(nums[3], c, ans);
          deal<90 & 16>(nums[4], c, ans);
          deal<90 & 32>(nums[5], c, ans);
          deal<90 & 64>(nums[6], c, ans);
          deal<90 & 128>(nums[7], c, ans);
          break;
        };
        case 91: {
          deal<91 & 1>(nums[0], c, ans);
          deal<91 & 2>(nums[1], c, ans);
          deal<91 & 4>(nums[2], c, ans);
          deal<91 & 8>(nums[3], c, ans);
          deal<91 & 16>(nums[4], c, ans);
          deal<91 & 32>(nums[5], c, ans);
          deal<91 & 64>(nums[6], c, ans);
          deal<91 & 128>(nums[7], c, ans);
          break;
        };
        case 92: {
          deal<92 & 1>(nums[0], c, ans);
          deal<92 & 2>(nums[1], c, ans);
          deal<92 & 4>(nums[2], c, ans);
          deal<92 & 8>(nums[3], c, ans);
          deal<92 & 16>(nums[4], c, ans);
          deal<92 & 32>(nums[5], c, ans);
          deal<92 & 64>(nums[6], c, ans);
          deal<92 & 128>(nums[7], c, ans);
          break;
        };
        case 93: {
          deal<93 & 1>(nums[0], c, ans);
          deal<93 & 2>(nums[1], c, ans);
          deal<93 & 4>(nums[2], c, ans);
          deal<93 & 8>(nums[3], c, ans);
          deal<93 & 16>(nums[4], c, ans);
          deal<93 & 32>(nums[5], c, ans);
          deal<93 & 64>(nums[6], c, ans);
          deal<93 & 128>(nums[7], c, ans);
          break;
        };
        case 94: {
          deal<94 & 1>(nums[0], c, ans);
          deal<94 & 2>(nums[1], c, ans);
          deal<94 & 4>(nums[2], c, ans);
          deal<94 & 8>(nums[3], c, ans);
          deal<94 & 16>(nums[4], c, ans);
          deal<94 & 32>(nums[5], c, ans);
          deal<94 & 64>(nums[6], c, ans);
          deal<94 & 128>(nums[7], c, ans);
          break;
        };
        case 95: {
          deal<95 & 1>(nums[0], c, ans);
          deal<95 & 2>(nums[1], c, ans);
          deal<95 & 4>(nums[2], c, ans);
          deal<95 & 8>(nums[3], c, ans);
          deal<95 & 16>(nums[4], c, ans);
          deal<95 & 32>(nums[5], c, ans);
          deal<95 & 64>(nums[6], c, ans);
          deal<95 & 128>(nums[7], c, ans);
          break;
        };
        case 96: {
          deal<96 & 1>(nums[0], c, ans);
          deal<96 & 2>(nums[1], c, ans);
          deal<96 & 4>(nums[2], c, ans);
          deal<96 & 8>(nums[3], c, ans);
          deal<96 & 16>(nums[4], c, ans);
          deal<96 & 32>(nums[5], c, ans);
          deal<96 & 64>(nums[6], c, ans);
          deal<96 & 128>(nums[7], c, ans);
          break;
        };
        case 97: {
          deal<97 & 1>(nums[0], c, ans);
          deal<97 & 2>(nums[1], c, ans);
          deal<97 & 4>(nums[2], c, ans);
          deal<97 & 8>(nums[3], c, ans);
          deal<97 & 16>(nums[4], c, ans);
          deal<97 & 32>(nums[5], c, ans);
          deal<97 & 64>(nums[6], c, ans);
          deal<97 & 128>(nums[7], c, ans);
          break;
        };
        case 98: {
          deal<98 & 1>(nums[0], c, ans);
          deal<98 & 2>(nums[1], c, ans);
          deal<98 & 4>(nums[2], c, ans);
          deal<98 & 8>(nums[3], c, ans);
          deal<98 & 16>(nums[4], c, ans);
          deal<98 & 32>(nums[5], c, ans);
          deal<98 & 64>(nums[6], c, ans);
          deal<98 & 128>(nums[7], c, ans);
          break;
        };
        case 99: {
          deal<99 & 1>(nums[0], c, ans);
          deal<99 & 2>(nums[1], c, ans);
          deal<99 & 4>(nums[2], c, ans);
          deal<99 & 8>(nums[3], c, ans);
          deal<99 & 16>(nums[4], c, ans);
          deal<99 & 32>(nums[5], c, ans);
          deal<99 & 64>(nums[6], c, ans);
          deal<99 & 128>(nums[7], c, ans);
          break;
        };
        case 100: {
          deal<100 & 1>(nums[0], c, ans);
          deal<100 & 2>(nums[1], c, ans);
          deal<100 & 4>(nums[2], c, ans);
          deal<100 & 8>(nums[3], c, ans);
          deal<100 & 16>(nums[4], c, ans);
          deal<100 & 32>(nums[5], c, ans);
          deal<100 & 64>(nums[6], c, ans);
          deal<100 & 128>(nums[7], c, ans);
          break;
        };
        case 101: {
          deal<101 & 1>(nums[0], c, ans);
          deal<101 & 2>(nums[1], c, ans);
          deal<101 & 4>(nums[2], c, ans);
          deal<101 & 8>(nums[3], c, ans);
          deal<101 & 16>(nums[4], c, ans);
          deal<101 & 32>(nums[5], c, ans);
          deal<101 & 64>(nums[6], c, ans);
          deal<101 & 128>(nums[7], c, ans);
          break;
        };
        case 102: {
          deal<102 & 1>(nums[0], c, ans);
          deal<102 & 2>(nums[1], c, ans);
          deal<102 & 4>(nums[2], c, ans);
          deal<102 & 8>(nums[3], c, ans);
          deal<102 & 16>(nums[4], c, ans);
          deal<102 & 32>(nums[5], c, ans);
          deal<102 & 64>(nums[6], c, ans);
          deal<102 & 128>(nums[7], c, ans);
          break;
        };
        case 103: {
          deal<103 & 1>(nums[0], c, ans);
          deal<103 & 2>(nums[1], c, ans);
          deal<103 & 4>(nums[2], c, ans);
          deal<103 & 8>(nums[3], c, ans);
          deal<103 & 16>(nums[4], c, ans);
          deal<103 & 32>(nums[5], c, ans);
          deal<103 & 64>(nums[6], c, ans);
          deal<103 & 128>(nums[7], c, ans);
          break;
        };
        case 104: {
          deal<104 & 1>(nums[0], c, ans);
          deal<104 & 2>(nums[1], c, ans);
          deal<104 & 4>(nums[2], c, ans);
          deal<104 & 8>(nums[3], c, ans);
          deal<104 & 16>(nums[4], c, ans);
          deal<104 & 32>(nums[5], c, ans);
          deal<104 & 64>(nums[6], c, ans);
          deal<104 & 128>(nums[7], c, ans);
          break;
        };
        case 105: {
          deal<105 & 1>(nums[0], c, ans);
          deal<105 & 2>(nums[1], c, ans);
          deal<105 & 4>(nums[2], c, ans);
          deal<105 & 8>(nums[3], c, ans);
          deal<105 & 16>(nums[4], c, ans);
          deal<105 & 32>(nums[5], c, ans);
          deal<105 & 64>(nums[6], c, ans);
          deal<105 & 128>(nums[7], c, ans);
          break;
        };
        case 106: {
          deal<106 & 1>(nums[0], c, ans);
          deal<106 & 2>(nums[1], c, ans);
          deal<106 & 4>(nums[2], c, ans);
          deal<106 & 8>(nums[3], c, ans);
          deal<106 & 16>(nums[4], c, ans);
          deal<106 & 32>(nums[5], c, ans);
          deal<106 & 64>(nums[6], c, ans);
          deal<106 & 128>(nums[7], c, ans);
          break;
        };
        case 107: {
          deal<107 & 1>(nums[0], c, ans);
          deal<107 & 2>(nums[1], c, ans);
          deal<107 & 4>(nums[2], c, ans);
          deal<107 & 8>(nums[3], c, ans);
          deal<107 & 16>(nums[4], c, ans);
          deal<107 & 32>(nums[5], c, ans);
          deal<107 & 64>(nums[6], c, ans);
          deal<107 & 128>(nums[7], c, ans);
          break;
        };
        case 108: {
          deal<108 & 1>(nums[0], c, ans);
          deal<108 & 2>(nums[1], c, ans);
          deal<108 & 4>(nums[2], c, ans);
          deal<108 & 8>(nums[3], c, ans);
          deal<108 & 16>(nums[4], c, ans);
          deal<108 & 32>(nums[5], c, ans);
          deal<108 & 64>(nums[6], c, ans);
          deal<108 & 128>(nums[7], c, ans);
          break;
        };
        case 109: {
          deal<109 & 1>(nums[0], c, ans);
          deal<109 & 2>(nums[1], c, ans);
          deal<109 & 4>(nums[2], c, ans);
          deal<109 & 8>(nums[3], c, ans);
          deal<109 & 16>(nums[4], c, ans);
          deal<109 & 32>(nums[5], c, ans);
          deal<109 & 64>(nums[6], c, ans);
          deal<109 & 128>(nums[7], c, ans);
          break;
        };
        case 110: {
          deal<110 & 1>(nums[0], c, ans);
          deal<110 & 2>(nums[1], c, ans);
          deal<110 & 4>(nums[2], c, ans);
          deal<110 & 8>(nums[3], c, ans);
          deal<110 & 16>(nums[4], c, ans);
          deal<110 & 32>(nums[5], c, ans);
          deal<110 & 64>(nums[6], c, ans);
          deal<110 & 128>(nums[7], c, ans);
          break;
        };
        case 111: {
          deal<111 & 1>(nums[0], c, ans);
          deal<111 & 2>(nums[1], c, ans);
          deal<111 & 4>(nums[2], c, ans);
          deal<111 & 8>(nums[3], c, ans);
          deal<111 & 16>(nums[4], c, ans);
          deal<111 & 32>(nums[5], c, ans);
          deal<111 & 64>(nums[6], c, ans);
          deal<111 & 128>(nums[7], c, ans);
          break;
        };
        case 112: {
          deal<112 & 1>(nums[0], c, ans);
          deal<112 & 2>(nums[1], c, ans);
          deal<112 & 4>(nums[2], c, ans);
          deal<112 & 8>(nums[3], c, ans);
          deal<112 & 16>(nums[4], c, ans);
          deal<112 & 32>(nums[5], c, ans);
          deal<112 & 64>(nums[6], c, ans);
          deal<112 & 128>(nums[7], c, ans);
          break;
        };
        case 113: {
          deal<113 & 1>(nums[0], c, ans);
          deal<113 & 2>(nums[1], c, ans);
          deal<113 & 4>(nums[2], c, ans);
          deal<113 & 8>(nums[3], c, ans);
          deal<113 & 16>(nums[4], c, ans);
          deal<113 & 32>(nums[5], c, ans);
          deal<113 & 64>(nums[6], c, ans);
          deal<113 & 128>(nums[7], c, ans);
          break;
        };
        case 114: {
          deal<114 & 1>(nums[0], c, ans);
          deal<114 & 2>(nums[1], c, ans);
          deal<114 & 4>(nums[2], c, ans);
          deal<114 & 8>(nums[3], c, ans);
          deal<114 & 16>(nums[4], c, ans);
          deal<114 & 32>(nums[5], c, ans);
          deal<114 & 64>(nums[6], c, ans);
          deal<114 & 128>(nums[7], c, ans);
          break;
        };
        case 115: {
          deal<115 & 1>(nums[0], c, ans);
          deal<115 & 2>(nums[1], c, ans);
          deal<115 & 4>(nums[2], c, ans);
          deal<115 & 8>(nums[3], c, ans);
          deal<115 & 16>(nums[4], c, ans);
          deal<115 & 32>(nums[5], c, ans);
          deal<115 & 64>(nums[6], c, ans);
          deal<115 & 128>(nums[7], c, ans);
          break;
        };
        case 116: {
          deal<116 & 1>(nums[0], c, ans);
          deal<116 & 2>(nums[1], c, ans);
          deal<116 & 4>(nums[2], c, ans);
          deal<116 & 8>(nums[3], c, ans);
          deal<116 & 16>(nums[4], c, ans);
          deal<116 & 32>(nums[5], c, ans);
          deal<116 & 64>(nums[6], c, ans);
          deal<116 & 128>(nums[7], c, ans);
          break;
        };
        case 117: {
          deal<117 & 1>(nums[0], c, ans);
          deal<117 & 2>(nums[1], c, ans);
          deal<117 & 4>(nums[2], c, ans);
          deal<117 & 8>(nums[3], c, ans);
          deal<117 & 16>(nums[4], c, ans);
          deal<117 & 32>(nums[5], c, ans);
          deal<117 & 64>(nums[6], c, ans);
          deal<117 & 128>(nums[7], c, ans);
          break;
        };
        case 118: {
          deal<118 & 1>(nums[0], c, ans);
          deal<118 & 2>(nums[1], c, ans);
          deal<118 & 4>(nums[2], c, ans);
          deal<118 & 8>(nums[3], c, ans);
          deal<118 & 16>(nums[4], c, ans);
          deal<118 & 32>(nums[5], c, ans);
          deal<118 & 64>(nums[6], c, ans);
          deal<118 & 128>(nums[7], c, ans);
          break;
        };
        case 119: {
          deal<119 & 1>(nums[0], c, ans);
          deal<119 & 2>(nums[1], c, ans);
          deal<119 & 4>(nums[2], c, ans);
          deal<119 & 8>(nums[3], c, ans);
          deal<119 & 16>(nums[4], c, ans);
          deal<119 & 32>(nums[5], c, ans);
          deal<119 & 64>(nums[6], c, ans);
          deal<119 & 128>(nums[7], c, ans);
          break;
        };
        case 120: {
          deal<120 & 1>(nums[0], c, ans);
          deal<120 & 2>(nums[1], c, ans);
          deal<120 & 4>(nums[2], c, ans);
          deal<120 & 8>(nums[3], c, ans);
          deal<120 & 16>(nums[4], c, ans);
          deal<120 & 32>(nums[5], c, ans);
          deal<120 & 64>(nums[6], c, ans);
          deal<120 & 128>(nums[7], c, ans);
          break;
        };
        case 121: {
          deal<121 & 1>(nums[0], c, ans);
          deal<121 & 2>(nums[1], c, ans);
          deal<121 & 4>(nums[2], c, ans);
          deal<121 & 8>(nums[3], c, ans);
          deal<121 & 16>(nums[4], c, ans);
          deal<121 & 32>(nums[5], c, ans);
          deal<121 & 64>(nums[6], c, ans);
          deal<121 & 128>(nums[7], c, ans);
          break;
        };
        case 122: {
          deal<122 & 1>(nums[0], c, ans);
          deal<122 & 2>(nums[1], c, ans);
          deal<122 & 4>(nums[2], c, ans);
          deal<122 & 8>(nums[3], c, ans);
          deal<122 & 16>(nums[4], c, ans);
          deal<122 & 32>(nums[5], c, ans);
          deal<122 & 64>(nums[6], c, ans);
          deal<122 & 128>(nums[7], c, ans);
          break;
        };
        case 123: {
          deal<123 & 1>(nums[0], c, ans);
          deal<123 & 2>(nums[1], c, ans);
          deal<123 & 4>(nums[2], c, ans);
          deal<123 & 8>(nums[3], c, ans);
          deal<123 & 16>(nums[4], c, ans);
          deal<123 & 32>(nums[5], c, ans);
          deal<123 & 64>(nums[6], c, ans);
          deal<123 & 128>(nums[7], c, ans);
          break;
        };
        case 124: {
          deal<124 & 1>(nums[0], c, ans);
          deal<124 & 2>(nums[1], c, ans);
          deal<124 & 4>(nums[2], c, ans);
          deal<124 & 8>(nums[3], c, ans);
          deal<124 & 16>(nums[4], c, ans);
          deal<124 & 32>(nums[5], c, ans);
          deal<124 & 64>(nums[6], c, ans);
          deal<124 & 128>(nums[7], c, ans);
          break;
        };
        case 125: {
          deal<125 & 1>(nums[0], c, ans);
          deal<125 & 2>(nums[1], c, ans);
          deal<125 & 4>(nums[2], c, ans);
          deal<125 & 8>(nums[3], c, ans);
          deal<125 & 16>(nums[4], c, ans);
          deal<125 & 32>(nums[5], c, ans);
          deal<125 & 64>(nums[6], c, ans);
          deal<125 & 128>(nums[7], c, ans);
          break;
        };
        case 126: {
          deal<126 & 1>(nums[0], c, ans);
          deal<126 & 2>(nums[1], c, ans);
          deal<126 & 4>(nums[2], c, ans);
          deal<126 & 8>(nums[3], c, ans);
          deal<126 & 16>(nums[4], c, ans);
          deal<126 & 32>(nums[5], c, ans);
          deal<126 & 64>(nums[6], c, ans);
          deal<126 & 128>(nums[7], c, ans);
          break;
        };
        case 127: {
          deal<127 & 1>(nums[0], c, ans);
          deal<127 & 2>(nums[1], c, ans);
          deal<127 & 4>(nums[2], c, ans);
          deal<127 & 8>(nums[3], c, ans);
          deal<127 & 16>(nums[4], c, ans);
          deal<127 & 32>(nums[5], c, ans);
          deal<127 & 64>(nums[6], c, ans);
          deal<127 & 128>(nums[7], c, ans);
          break;
        };
        case 128: {
          deal<128 & 1>(nums[0], c, ans);
          deal<128 & 2>(nums[1], c, ans);
          deal<128 & 4>(nums[2], c, ans);
          deal<128 & 8>(nums[3], c, ans);
          deal<128 & 16>(nums[4], c, ans);
          deal<128 & 32>(nums[5], c, ans);
          deal<128 & 64>(nums[6], c, ans);
          deal<128 & 128>(nums[7], c, ans);
          break;
        };
        case 129: {
          deal<129 & 1>(nums[0], c, ans);
          deal<129 & 2>(nums[1], c, ans);
          deal<129 & 4>(nums[2], c, ans);
          deal<129 & 8>(nums[3], c, ans);
          deal<129 & 16>(nums[4], c, ans);
          deal<129 & 32>(nums[5], c, ans);
          deal<129 & 64>(nums[6], c, ans);
          deal<129 & 128>(nums[7], c, ans);
          break;
        };
        case 130: {
          deal<130 & 1>(nums[0], c, ans);
          deal<130 & 2>(nums[1], c, ans);
          deal<130 & 4>(nums[2], c, ans);
          deal<130 & 8>(nums[3], c, ans);
          deal<130 & 16>(nums[4], c, ans);
          deal<130 & 32>(nums[5], c, ans);
          deal<130 & 64>(nums[6], c, ans);
          deal<130 & 128>(nums[7], c, ans);
          break;
        };
        case 131: {
          deal<131 & 1>(nums[0], c, ans);
          deal<131 & 2>(nums[1], c, ans);
          deal<131 & 4>(nums[2], c, ans);
          deal<131 & 8>(nums[3], c, ans);
          deal<131 & 16>(nums[4], c, ans);
          deal<131 & 32>(nums[5], c, ans);
          deal<131 & 64>(nums[6], c, ans);
          deal<131 & 128>(nums[7], c, ans);
          break;
        };
        case 132: {
          deal<132 & 1>(nums[0], c, ans);
          deal<132 & 2>(nums[1], c, ans);
          deal<132 & 4>(nums[2], c, ans);
          deal<132 & 8>(nums[3], c, ans);
          deal<132 & 16>(nums[4], c, ans);
          deal<132 & 32>(nums[5], c, ans);
          deal<132 & 64>(nums[6], c, ans);
          deal<132 & 128>(nums[7], c, ans);
          break;
        };
        case 133: {
          deal<133 & 1>(nums[0], c, ans);
          deal<133 & 2>(nums[1], c, ans);
          deal<133 & 4>(nums[2], c, ans);
          deal<133 & 8>(nums[3], c, ans);
          deal<133 & 16>(nums[4], c, ans);
          deal<133 & 32>(nums[5], c, ans);
          deal<133 & 64>(nums[6], c, ans);
          deal<133 & 128>(nums[7], c, ans);
          break;
        };
        case 134: {
          deal<134 & 1>(nums[0], c, ans);
          deal<134 & 2>(nums[1], c, ans);
          deal<134 & 4>(nums[2], c, ans);
          deal<134 & 8>(nums[3], c, ans);
          deal<134 & 16>(nums[4], c, ans);
          deal<134 & 32>(nums[5], c, ans);
          deal<134 & 64>(nums[6], c, ans);
          deal<134 & 128>(nums[7], c, ans);
          break;
        };
        case 135: {
          deal<135 & 1>(nums[0], c, ans);
          deal<135 & 2>(nums[1], c, ans);
          deal<135 & 4>(nums[2], c, ans);
          deal<135 & 8>(nums[3], c, ans);
          deal<135 & 16>(nums[4], c, ans);
          deal<135 & 32>(nums[5], c, ans);
          deal<135 & 64>(nums[6], c, ans);
          deal<135 & 128>(nums[7], c, ans);
          break;
        };
        case 136: {
          deal<136 & 1>(nums[0], c, ans);
          deal<136 & 2>(nums[1], c, ans);
          deal<136 & 4>(nums[2], c, ans);
          deal<136 & 8>(nums[3], c, ans);
          deal<136 & 16>(nums[4], c, ans);
          deal<136 & 32>(nums[5], c, ans);
          deal<136 & 64>(nums[6], c, ans);
          deal<136 & 128>(nums[7], c, ans);
          break;
        };
        case 137: {
          deal<137 & 1>(nums[0], c, ans);
          deal<137 & 2>(nums[1], c, ans);
          deal<137 & 4>(nums[2], c, ans);
          deal<137 & 8>(nums[3], c, ans);
          deal<137 & 16>(nums[4], c, ans);
          deal<137 & 32>(nums[5], c, ans);
          deal<137 & 64>(nums[6], c, ans);
          deal<137 & 128>(nums[7], c, ans);
          break;
        };
        case 138: {
          deal<138 & 1>(nums[0], c, ans);
          deal<138 & 2>(nums[1], c, ans);
          deal<138 & 4>(nums[2], c, ans);
          deal<138 & 8>(nums[3], c, ans);
          deal<138 & 16>(nums[4], c, ans);
          deal<138 & 32>(nums[5], c, ans);
          deal<138 & 64>(nums[6], c, ans);
          deal<138 & 128>(nums[7], c, ans);
          break;
        };
        case 139: {
          deal<139 & 1>(nums[0], c, ans);
          deal<139 & 2>(nums[1], c, ans);
          deal<139 & 4>(nums[2], c, ans);
          deal<139 & 8>(nums[3], c, ans);
          deal<139 & 16>(nums[4], c, ans);
          deal<139 & 32>(nums[5], c, ans);
          deal<139 & 64>(nums[6], c, ans);
          deal<139 & 128>(nums[7], c, ans);
          break;
        };
        case 140: {
          deal<140 & 1>(nums[0], c, ans);
          deal<140 & 2>(nums[1], c, ans);
          deal<140 & 4>(nums[2], c, ans);
          deal<140 & 8>(nums[3], c, ans);
          deal<140 & 16>(nums[4], c, ans);
          deal<140 & 32>(nums[5], c, ans);
          deal<140 & 64>(nums[6], c, ans);
          deal<140 & 128>(nums[7], c, ans);
          break;
        };
        case 141: {
          deal<141 & 1>(nums[0], c, ans);
          deal<141 & 2>(nums[1], c, ans);
          deal<141 & 4>(nums[2], c, ans);
          deal<141 & 8>(nums[3], c, ans);
          deal<141 & 16>(nums[4], c, ans);
          deal<141 & 32>(nums[5], c, ans);
          deal<141 & 64>(nums[6], c, ans);
          deal<141 & 128>(nums[7], c, ans);
          break;
        };
        case 142: {
          deal<142 & 1>(nums[0], c, ans);
          deal<142 & 2>(nums[1], c, ans);
          deal<142 & 4>(nums[2], c, ans);
          deal<142 & 8>(nums[3], c, ans);
          deal<142 & 16>(nums[4], c, ans);
          deal<142 & 32>(nums[5], c, ans);
          deal<142 & 64>(nums[6], c, ans);
          deal<142 & 128>(nums[7], c, ans);
          break;
        };
        case 143: {
          deal<143 & 1>(nums[0], c, ans);
          deal<143 & 2>(nums[1], c, ans);
          deal<143 & 4>(nums[2], c, ans);
          deal<143 & 8>(nums[3], c, ans);
          deal<143 & 16>(nums[4], c, ans);
          deal<143 & 32>(nums[5], c, ans);
          deal<143 & 64>(nums[6], c, ans);
          deal<143 & 128>(nums[7], c, ans);
          break;
        };
        case 144: {
          deal<144 & 1>(nums[0], c, ans);
          deal<144 & 2>(nums[1], c, ans);
          deal<144 & 4>(nums[2], c, ans);
          deal<144 & 8>(nums[3], c, ans);
          deal<144 & 16>(nums[4], c, ans);
          deal<144 & 32>(nums[5], c, ans);
          deal<144 & 64>(nums[6], c, ans);
          deal<144 & 128>(nums[7], c, ans);
          break;
        };
        case 145: {
          deal<145 & 1>(nums[0], c, ans);
          deal<145 & 2>(nums[1], c, ans);
          deal<145 & 4>(nums[2], c, ans);
          deal<145 & 8>(nums[3], c, ans);
          deal<145 & 16>(nums[4], c, ans);
          deal<145 & 32>(nums[5], c, ans);
          deal<145 & 64>(nums[6], c, ans);
          deal<145 & 128>(nums[7], c, ans);
          break;
        };
        case 146: {
          deal<146 & 1>(nums[0], c, ans);
          deal<146 & 2>(nums[1], c, ans);
          deal<146 & 4>(nums[2], c, ans);
          deal<146 & 8>(nums[3], c, ans);
          deal<146 & 16>(nums[4], c, ans);
          deal<146 & 32>(nums[5], c, ans);
          deal<146 & 64>(nums[6], c, ans);
          deal<146 & 128>(nums[7], c, ans);
          break;
        };
        case 147: {
          deal<147 & 1>(nums[0], c, ans);
          deal<147 & 2>(nums[1], c, ans);
          deal<147 & 4>(nums[2], c, ans);
          deal<147 & 8>(nums[3], c, ans);
          deal<147 & 16>(nums[4], c, ans);
          deal<147 & 32>(nums[5], c, ans);
          deal<147 & 64>(nums[6], c, ans);
          deal<147 & 128>(nums[7], c, ans);
          break;
        };
        case 148: {
          deal<148 & 1>(nums[0], c, ans);
          deal<148 & 2>(nums[1], c, ans);
          deal<148 & 4>(nums[2], c, ans);
          deal<148 & 8>(nums[3], c, ans);
          deal<148 & 16>(nums[4], c, ans);
          deal<148 & 32>(nums[5], c, ans);
          deal<148 & 64>(nums[6], c, ans);
          deal<148 & 128>(nums[7], c, ans);
          break;
        };
        case 149: {
          deal<149 & 1>(nums[0], c, ans);
          deal<149 & 2>(nums[1], c, ans);
          deal<149 & 4>(nums[2], c, ans);
          deal<149 & 8>(nums[3], c, ans);
          deal<149 & 16>(nums[4], c, ans);
          deal<149 & 32>(nums[5], c, ans);
          deal<149 & 64>(nums[6], c, ans);
          deal<149 & 128>(nums[7], c, ans);
          break;
        };
        case 150: {
          deal<150 & 1>(nums[0], c, ans);
          deal<150 & 2>(nums[1], c, ans);
          deal<150 & 4>(nums[2], c, ans);
          deal<150 & 8>(nums[3], c, ans);
          deal<150 & 16>(nums[4], c, ans);
          deal<150 & 32>(nums[5], c, ans);
          deal<150 & 64>(nums[6], c, ans);
          deal<150 & 128>(nums[7], c, ans);
          break;
        };
        case 151: {
          deal<151 & 1>(nums[0], c, ans);
          deal<151 & 2>(nums[1], c, ans);
          deal<151 & 4>(nums[2], c, ans);
          deal<151 & 8>(nums[3], c, ans);
          deal<151 & 16>(nums[4], c, ans);
          deal<151 & 32>(nums[5], c, ans);
          deal<151 & 64>(nums[6], c, ans);
          deal<151 & 128>(nums[7], c, ans);
          break;
        };
        case 152: {
          deal<152 & 1>(nums[0], c, ans);
          deal<152 & 2>(nums[1], c, ans);
          deal<152 & 4>(nums[2], c, ans);
          deal<152 & 8>(nums[3], c, ans);
          deal<152 & 16>(nums[4], c, ans);
          deal<152 & 32>(nums[5], c, ans);
          deal<152 & 64>(nums[6], c, ans);
          deal<152 & 128>(nums[7], c, ans);
          break;
        };
        case 153: {
          deal<153 & 1>(nums[0], c, ans);
          deal<153 & 2>(nums[1], c, ans);
          deal<153 & 4>(nums[2], c, ans);
          deal<153 & 8>(nums[3], c, ans);
          deal<153 & 16>(nums[4], c, ans);
          deal<153 & 32>(nums[5], c, ans);
          deal<153 & 64>(nums[6], c, ans);
          deal<153 & 128>(nums[7], c, ans);
          break;
        };
        case 154: {
          deal<154 & 1>(nums[0], c, ans);
          deal<154 & 2>(nums[1], c, ans);
          deal<154 & 4>(nums[2], c, ans);
          deal<154 & 8>(nums[3], c, ans);
          deal<154 & 16>(nums[4], c, ans);
          deal<154 & 32>(nums[5], c, ans);
          deal<154 & 64>(nums[6], c, ans);
          deal<154 & 128>(nums[7], c, ans);
          break;
        };
        case 155: {
          deal<155 & 1>(nums[0], c, ans);
          deal<155 & 2>(nums[1], c, ans);
          deal<155 & 4>(nums[2], c, ans);
          deal<155 & 8>(nums[3], c, ans);
          deal<155 & 16>(nums[4], c, ans);
          deal<155 & 32>(nums[5], c, ans);
          deal<155 & 64>(nums[6], c, ans);
          deal<155 & 128>(nums[7], c, ans);
          break;
        };
        case 156: {
          deal<156 & 1>(nums[0], c, ans);
          deal<156 & 2>(nums[1], c, ans);
          deal<156 & 4>(nums[2], c, ans);
          deal<156 & 8>(nums[3], c, ans);
          deal<156 & 16>(nums[4], c, ans);
          deal<156 & 32>(nums[5], c, ans);
          deal<156 & 64>(nums[6], c, ans);
          deal<156 & 128>(nums[7], c, ans);
          break;
        };
        case 157: {
          deal<157 & 1>(nums[0], c, ans);
          deal<157 & 2>(nums[1], c, ans);
          deal<157 & 4>(nums[2], c, ans);
          deal<157 & 8>(nums[3], c, ans);
          deal<157 & 16>(nums[4], c, ans);
          deal<157 & 32>(nums[5], c, ans);
          deal<157 & 64>(nums[6], c, ans);
          deal<157 & 128>(nums[7], c, ans);
          break;
        };
        case 158: {
          deal<158 & 1>(nums[0], c, ans);
          deal<158 & 2>(nums[1], c, ans);
          deal<158 & 4>(nums[2], c, ans);
          deal<158 & 8>(nums[3], c, ans);
          deal<158 & 16>(nums[4], c, ans);
          deal<158 & 32>(nums[5], c, ans);
          deal<158 & 64>(nums[6], c, ans);
          deal<158 & 128>(nums[7], c, ans);
          break;
        };
        case 159: {
          deal<159 & 1>(nums[0], c, ans);
          deal<159 & 2>(nums[1], c, ans);
          deal<159 & 4>(nums[2], c, ans);
          deal<159 & 8>(nums[3], c, ans);
          deal<159 & 16>(nums[4], c, ans);
          deal<159 & 32>(nums[5], c, ans);
          deal<159 & 64>(nums[6], c, ans);
          deal<159 & 128>(nums[7], c, ans);
          break;
        };
        case 160: {
          deal<160 & 1>(nums[0], c, ans);
          deal<160 & 2>(nums[1], c, ans);
          deal<160 & 4>(nums[2], c, ans);
          deal<160 & 8>(nums[3], c, ans);
          deal<160 & 16>(nums[4], c, ans);
          deal<160 & 32>(nums[5], c, ans);
          deal<160 & 64>(nums[6], c, ans);
          deal<160 & 128>(nums[7], c, ans);
          break;
        };
        case 161: {
          deal<161 & 1>(nums[0], c, ans);
          deal<161 & 2>(nums[1], c, ans);
          deal<161 & 4>(nums[2], c, ans);
          deal<161 & 8>(nums[3], c, ans);
          deal<161 & 16>(nums[4], c, ans);
          deal<161 & 32>(nums[5], c, ans);
          deal<161 & 64>(nums[6], c, ans);
          deal<161 & 128>(nums[7], c, ans);
          break;
        };
        case 162: {
          deal<162 & 1>(nums[0], c, ans);
          deal<162 & 2>(nums[1], c, ans);
          deal<162 & 4>(nums[2], c, ans);
          deal<162 & 8>(nums[3], c, ans);
          deal<162 & 16>(nums[4], c, ans);
          deal<162 & 32>(nums[5], c, ans);
          deal<162 & 64>(nums[6], c, ans);
          deal<162 & 128>(nums[7], c, ans);
          break;
        };
        case 163: {
          deal<163 & 1>(nums[0], c, ans);
          deal<163 & 2>(nums[1], c, ans);
          deal<163 & 4>(nums[2], c, ans);
          deal<163 & 8>(nums[3], c, ans);
          deal<163 & 16>(nums[4], c, ans);
          deal<163 & 32>(nums[5], c, ans);
          deal<163 & 64>(nums[6], c, ans);
          deal<163 & 128>(nums[7], c, ans);
          break;
        };
        case 164: {
          deal<164 & 1>(nums[0], c, ans);
          deal<164 & 2>(nums[1], c, ans);
          deal<164 & 4>(nums[2], c, ans);
          deal<164 & 8>(nums[3], c, ans);
          deal<164 & 16>(nums[4], c, ans);
          deal<164 & 32>(nums[5], c, ans);
          deal<164 & 64>(nums[6], c, ans);
          deal<164 & 128>(nums[7], c, ans);
          break;
        };
        case 165: {
          deal<165 & 1>(nums[0], c, ans);
          deal<165 & 2>(nums[1], c, ans);
          deal<165 & 4>(nums[2], c, ans);
          deal<165 & 8>(nums[3], c, ans);
          deal<165 & 16>(nums[4], c, ans);
          deal<165 & 32>(nums[5], c, ans);
          deal<165 & 64>(nums[6], c, ans);
          deal<165 & 128>(nums[7], c, ans);
          break;
        };
        case 166: {
          deal<166 & 1>(nums[0], c, ans);
          deal<166 & 2>(nums[1], c, ans);
          deal<166 & 4>(nums[2], c, ans);
          deal<166 & 8>(nums[3], c, ans);
          deal<166 & 16>(nums[4], c, ans);
          deal<166 & 32>(nums[5], c, ans);
          deal<166 & 64>(nums[6], c, ans);
          deal<166 & 128>(nums[7], c, ans);
          break;
        };
        case 167: {
          deal<167 & 1>(nums[0], c, ans);
          deal<167 & 2>(nums[1], c, ans);
          deal<167 & 4>(nums[2], c, ans);
          deal<167 & 8>(nums[3], c, ans);
          deal<167 & 16>(nums[4], c, ans);
          deal<167 & 32>(nums[5], c, ans);
          deal<167 & 64>(nums[6], c, ans);
          deal<167 & 128>(nums[7], c, ans);
          break;
        };
        case 168: {
          deal<168 & 1>(nums[0], c, ans);
          deal<168 & 2>(nums[1], c, ans);
          deal<168 & 4>(nums[2], c, ans);
          deal<168 & 8>(nums[3], c, ans);
          deal<168 & 16>(nums[4], c, ans);
          deal<168 & 32>(nums[5], c, ans);
          deal<168 & 64>(nums[6], c, ans);
          deal<168 & 128>(nums[7], c, ans);
          break;
        };
        case 169: {
          deal<169 & 1>(nums[0], c, ans);
          deal<169 & 2>(nums[1], c, ans);
          deal<169 & 4>(nums[2], c, ans);
          deal<169 & 8>(nums[3], c, ans);
          deal<169 & 16>(nums[4], c, ans);
          deal<169 & 32>(nums[5], c, ans);
          deal<169 & 64>(nums[6], c, ans);
          deal<169 & 128>(nums[7], c, ans);
          break;
        };
        case 170: {
          deal<170 & 1>(nums[0], c, ans);
          deal<170 & 2>(nums[1], c, ans);
          deal<170 & 4>(nums[2], c, ans);
          deal<170 & 8>(nums[3], c, ans);
          deal<170 & 16>(nums[4], c, ans);
          deal<170 & 32>(nums[5], c, ans);
          deal<170 & 64>(nums[6], c, ans);
          deal<170 & 128>(nums[7], c, ans);
          break;
        };
        case 171: {
          deal<171 & 1>(nums[0], c, ans);
          deal<171 & 2>(nums[1], c, ans);
          deal<171 & 4>(nums[2], c, ans);
          deal<171 & 8>(nums[3], c, ans);
          deal<171 & 16>(nums[4], c, ans);
          deal<171 & 32>(nums[5], c, ans);
          deal<171 & 64>(nums[6], c, ans);
          deal<171 & 128>(nums[7], c, ans);
          break;
        };
        case 172: {
          deal<172 & 1>(nums[0], c, ans);
          deal<172 & 2>(nums[1], c, ans);
          deal<172 & 4>(nums[2], c, ans);
          deal<172 & 8>(nums[3], c, ans);
          deal<172 & 16>(nums[4], c, ans);
          deal<172 & 32>(nums[5], c, ans);
          deal<172 & 64>(nums[6], c, ans);
          deal<172 & 128>(nums[7], c, ans);
          break;
        };
        case 173: {
          deal<173 & 1>(nums[0], c, ans);
          deal<173 & 2>(nums[1], c, ans);
          deal<173 & 4>(nums[2], c, ans);
          deal<173 & 8>(nums[3], c, ans);
          deal<173 & 16>(nums[4], c, ans);
          deal<173 & 32>(nums[5], c, ans);
          deal<173 & 64>(nums[6], c, ans);
          deal<173 & 128>(nums[7], c, ans);
          break;
        };
        case 174: {
          deal<174 & 1>(nums[0], c, ans);
          deal<174 & 2>(nums[1], c, ans);
          deal<174 & 4>(nums[2], c, ans);
          deal<174 & 8>(nums[3], c, ans);
          deal<174 & 16>(nums[4], c, ans);
          deal<174 & 32>(nums[5], c, ans);
          deal<174 & 64>(nums[6], c, ans);
          deal<174 & 128>(nums[7], c, ans);
          break;
        };
        case 175: {
          deal<175 & 1>(nums[0], c, ans);
          deal<175 & 2>(nums[1], c, ans);
          deal<175 & 4>(nums[2], c, ans);
          deal<175 & 8>(nums[3], c, ans);
          deal<175 & 16>(nums[4], c, ans);
          deal<175 & 32>(nums[5], c, ans);
          deal<175 & 64>(nums[6], c, ans);
          deal<175 & 128>(nums[7], c, ans);
          break;
        };
        case 176: {
          deal<176 & 1>(nums[0], c, ans);
          deal<176 & 2>(nums[1], c, ans);
          deal<176 & 4>(nums[2], c, ans);
          deal<176 & 8>(nums[3], c, ans);
          deal<176 & 16>(nums[4], c, ans);
          deal<176 & 32>(nums[5], c, ans);
          deal<176 & 64>(nums[6], c, ans);
          deal<176 & 128>(nums[7], c, ans);
          break;
        };
        case 177: {
          deal<177 & 1>(nums[0], c, ans);
          deal<177 & 2>(nums[1], c, ans);
          deal<177 & 4>(nums[2], c, ans);
          deal<177 & 8>(nums[3], c, ans);
          deal<177 & 16>(nums[4], c, ans);
          deal<177 & 32>(nums[5], c, ans);
          deal<177 & 64>(nums[6], c, ans);
          deal<177 & 128>(nums[7], c, ans);
          break;
        };
        case 178: {
          deal<178 & 1>(nums[0], c, ans);
          deal<178 & 2>(nums[1], c, ans);
          deal<178 & 4>(nums[2], c, ans);
          deal<178 & 8>(nums[3], c, ans);
          deal<178 & 16>(nums[4], c, ans);
          deal<178 & 32>(nums[5], c, ans);
          deal<178 & 64>(nums[6], c, ans);
          deal<178 & 128>(nums[7], c, ans);
          break;
        };
        case 179: {
          deal<179 & 1>(nums[0], c, ans);
          deal<179 & 2>(nums[1], c, ans);
          deal<179 & 4>(nums[2], c, ans);
          deal<179 & 8>(nums[3], c, ans);
          deal<179 & 16>(nums[4], c, ans);
          deal<179 & 32>(nums[5], c, ans);
          deal<179 & 64>(nums[6], c, ans);
          deal<179 & 128>(nums[7], c, ans);
          break;
        };
        case 180: {
          deal<180 & 1>(nums[0], c, ans);
          deal<180 & 2>(nums[1], c, ans);
          deal<180 & 4>(nums[2], c, ans);
          deal<180 & 8>(nums[3], c, ans);
          deal<180 & 16>(nums[4], c, ans);
          deal<180 & 32>(nums[5], c, ans);
          deal<180 & 64>(nums[6], c, ans);
          deal<180 & 128>(nums[7], c, ans);
          break;
        };
        case 181: {
          deal<181 & 1>(nums[0], c, ans);
          deal<181 & 2>(nums[1], c, ans);
          deal<181 & 4>(nums[2], c, ans);
          deal<181 & 8>(nums[3], c, ans);
          deal<181 & 16>(nums[4], c, ans);
          deal<181 & 32>(nums[5], c, ans);
          deal<181 & 64>(nums[6], c, ans);
          deal<181 & 128>(nums[7], c, ans);
          break;
        };
        case 182: {
          deal<182 & 1>(nums[0], c, ans);
          deal<182 & 2>(nums[1], c, ans);
          deal<182 & 4>(nums[2], c, ans);
          deal<182 & 8>(nums[3], c, ans);
          deal<182 & 16>(nums[4], c, ans);
          deal<182 & 32>(nums[5], c, ans);
          deal<182 & 64>(nums[6], c, ans);
          deal<182 & 128>(nums[7], c, ans);
          break;
        };
        case 183: {
          deal<183 & 1>(nums[0], c, ans);
          deal<183 & 2>(nums[1], c, ans);
          deal<183 & 4>(nums[2], c, ans);
          deal<183 & 8>(nums[3], c, ans);
          deal<183 & 16>(nums[4], c, ans);
          deal<183 & 32>(nums[5], c, ans);
          deal<183 & 64>(nums[6], c, ans);
          deal<183 & 128>(nums[7], c, ans);
          break;
        };
        case 184: {
          deal<184 & 1>(nums[0], c, ans);
          deal<184 & 2>(nums[1], c, ans);
          deal<184 & 4>(nums[2], c, ans);
          deal<184 & 8>(nums[3], c, ans);
          deal<184 & 16>(nums[4], c, ans);
          deal<184 & 32>(nums[5], c, ans);
          deal<184 & 64>(nums[6], c, ans);
          deal<184 & 128>(nums[7], c, ans);
          break;
        };
        case 185: {
          deal<185 & 1>(nums[0], c, ans);
          deal<185 & 2>(nums[1], c, ans);
          deal<185 & 4>(nums[2], c, ans);
          deal<185 & 8>(nums[3], c, ans);
          deal<185 & 16>(nums[4], c, ans);
          deal<185 & 32>(nums[5], c, ans);
          deal<185 & 64>(nums[6], c, ans);
          deal<185 & 128>(nums[7], c, ans);
          break;
        };
        case 186: {
          deal<186 & 1>(nums[0], c, ans);
          deal<186 & 2>(nums[1], c, ans);
          deal<186 & 4>(nums[2], c, ans);
          deal<186 & 8>(nums[3], c, ans);
          deal<186 & 16>(nums[4], c, ans);
          deal<186 & 32>(nums[5], c, ans);
          deal<186 & 64>(nums[6], c, ans);
          deal<186 & 128>(nums[7], c, ans);
          break;
        };
        case 187: {
          deal<187 & 1>(nums[0], c, ans);
          deal<187 & 2>(nums[1], c, ans);
          deal<187 & 4>(nums[2], c, ans);
          deal<187 & 8>(nums[3], c, ans);
          deal<187 & 16>(nums[4], c, ans);
          deal<187 & 32>(nums[5], c, ans);
          deal<187 & 64>(nums[6], c, ans);
          deal<187 & 128>(nums[7], c, ans);
          break;
        };
        case 188: {
          deal<188 & 1>(nums[0], c, ans);
          deal<188 & 2>(nums[1], c, ans);
          deal<188 & 4>(nums[2], c, ans);
          deal<188 & 8>(nums[3], c, ans);
          deal<188 & 16>(nums[4], c, ans);
          deal<188 & 32>(nums[5], c, ans);
          deal<188 & 64>(nums[6], c, ans);
          deal<188 & 128>(nums[7], c, ans);
          break;
        };
        case 189: {
          deal<189 & 1>(nums[0], c, ans);
          deal<189 & 2>(nums[1], c, ans);
          deal<189 & 4>(nums[2], c, ans);
          deal<189 & 8>(nums[3], c, ans);
          deal<189 & 16>(nums[4], c, ans);
          deal<189 & 32>(nums[5], c, ans);
          deal<189 & 64>(nums[6], c, ans);
          deal<189 & 128>(nums[7], c, ans);
          break;
        };
        case 190: {
          deal<190 & 1>(nums[0], c, ans);
          deal<190 & 2>(nums[1], c, ans);
          deal<190 & 4>(nums[2], c, ans);
          deal<190 & 8>(nums[3], c, ans);
          deal<190 & 16>(nums[4], c, ans);
          deal<190 & 32>(nums[5], c, ans);
          deal<190 & 64>(nums[6], c, ans);
          deal<190 & 128>(nums[7], c, ans);
          break;
        };
        case 191: {
          deal<191 & 1>(nums[0], c, ans);
          deal<191 & 2>(nums[1], c, ans);
          deal<191 & 4>(nums[2], c, ans);
          deal<191 & 8>(nums[3], c, ans);
          deal<191 & 16>(nums[4], c, ans);
          deal<191 & 32>(nums[5], c, ans);
          deal<191 & 64>(nums[6], c, ans);
          deal<191 & 128>(nums[7], c, ans);
          break;
        };
        case 192: {
          deal<192 & 1>(nums[0], c, ans);
          deal<192 & 2>(nums[1], c, ans);
          deal<192 & 4>(nums[2], c, ans);
          deal<192 & 8>(nums[3], c, ans);
          deal<192 & 16>(nums[4], c, ans);
          deal<192 & 32>(nums[5], c, ans);
          deal<192 & 64>(nums[6], c, ans);
          deal<192 & 128>(nums[7], c, ans);
          break;
        };
        case 193: {
          deal<193 & 1>(nums[0], c, ans);
          deal<193 & 2>(nums[1], c, ans);
          deal<193 & 4>(nums[2], c, ans);
          deal<193 & 8>(nums[3], c, ans);
          deal<193 & 16>(nums[4], c, ans);
          deal<193 & 32>(nums[5], c, ans);
          deal<193 & 64>(nums[6], c, ans);
          deal<193 & 128>(nums[7], c, ans);
          break;
        };
        case 194: {
          deal<194 & 1>(nums[0], c, ans);
          deal<194 & 2>(nums[1], c, ans);
          deal<194 & 4>(nums[2], c, ans);
          deal<194 & 8>(nums[3], c, ans);
          deal<194 & 16>(nums[4], c, ans);
          deal<194 & 32>(nums[5], c, ans);
          deal<194 & 64>(nums[6], c, ans);
          deal<194 & 128>(nums[7], c, ans);
          break;
        };
        case 195: {
          deal<195 & 1>(nums[0], c, ans);
          deal<195 & 2>(nums[1], c, ans);
          deal<195 & 4>(nums[2], c, ans);
          deal<195 & 8>(nums[3], c, ans);
          deal<195 & 16>(nums[4], c, ans);
          deal<195 & 32>(nums[5], c, ans);
          deal<195 & 64>(nums[6], c, ans);
          deal<195 & 128>(nums[7], c, ans);
          break;
        };
        case 196: {
          deal<196 & 1>(nums[0], c, ans);
          deal<196 & 2>(nums[1], c, ans);
          deal<196 & 4>(nums[2], c, ans);
          deal<196 & 8>(nums[3], c, ans);
          deal<196 & 16>(nums[4], c, ans);
          deal<196 & 32>(nums[5], c, ans);
          deal<196 & 64>(nums[6], c, ans);
          deal<196 & 128>(nums[7], c, ans);
          break;
        };
        case 197: {
          deal<197 & 1>(nums[0], c, ans);
          deal<197 & 2>(nums[1], c, ans);
          deal<197 & 4>(nums[2], c, ans);
          deal<197 & 8>(nums[3], c, ans);
          deal<197 & 16>(nums[4], c, ans);
          deal<197 & 32>(nums[5], c, ans);
          deal<197 & 64>(nums[6], c, ans);
          deal<197 & 128>(nums[7], c, ans);
          break;
        };
        case 198: {
          deal<198 & 1>(nums[0], c, ans);
          deal<198 & 2>(nums[1], c, ans);
          deal<198 & 4>(nums[2], c, ans);
          deal<198 & 8>(nums[3], c, ans);
          deal<198 & 16>(nums[4], c, ans);
          deal<198 & 32>(nums[5], c, ans);
          deal<198 & 64>(nums[6], c, ans);
          deal<198 & 128>(nums[7], c, ans);
          break;
        };
        case 199: {
          deal<199 & 1>(nums[0], c, ans);
          deal<199 & 2>(nums[1], c, ans);
          deal<199 & 4>(nums[2], c, ans);
          deal<199 & 8>(nums[3], c, ans);
          deal<199 & 16>(nums[4], c, ans);
          deal<199 & 32>(nums[5], c, ans);
          deal<199 & 64>(nums[6], c, ans);
          deal<199 & 128>(nums[7], c, ans);
          break;
        };
        case 200: {
          deal<200 & 1>(nums[0], c, ans);
          deal<200 & 2>(nums[1], c, ans);
          deal<200 & 4>(nums[2], c, ans);
          deal<200 & 8>(nums[3], c, ans);
          deal<200 & 16>(nums[4], c, ans);
          deal<200 & 32>(nums[5], c, ans);
          deal<200 & 64>(nums[6], c, ans);
          deal<200 & 128>(nums[7], c, ans);
          break;
        };
        case 201: {
          deal<201 & 1>(nums[0], c, ans);
          deal<201 & 2>(nums[1], c, ans);
          deal<201 & 4>(nums[2], c, ans);
          deal<201 & 8>(nums[3], c, ans);
          deal<201 & 16>(nums[4], c, ans);
          deal<201 & 32>(nums[5], c, ans);
          deal<201 & 64>(nums[6], c, ans);
          deal<201 & 128>(nums[7], c, ans);
          break;
        };
        case 202: {
          deal<202 & 1>(nums[0], c, ans);
          deal<202 & 2>(nums[1], c, ans);
          deal<202 & 4>(nums[2], c, ans);
          deal<202 & 8>(nums[3], c, ans);
          deal<202 & 16>(nums[4], c, ans);
          deal<202 & 32>(nums[5], c, ans);
          deal<202 & 64>(nums[6], c, ans);
          deal<202 & 128>(nums[7], c, ans);
          break;
        };
        case 203: {
          deal<203 & 1>(nums[0], c, ans);
          deal<203 & 2>(nums[1], c, ans);
          deal<203 & 4>(nums[2], c, ans);
          deal<203 & 8>(nums[3], c, ans);
          deal<203 & 16>(nums[4], c, ans);
          deal<203 & 32>(nums[5], c, ans);
          deal<203 & 64>(nums[6], c, ans);
          deal<203 & 128>(nums[7], c, ans);
          break;
        };
        case 204: {
          deal<204 & 1>(nums[0], c, ans);
          deal<204 & 2>(nums[1], c, ans);
          deal<204 & 4>(nums[2], c, ans);
          deal<204 & 8>(nums[3], c, ans);
          deal<204 & 16>(nums[4], c, ans);
          deal<204 & 32>(nums[5], c, ans);
          deal<204 & 64>(nums[6], c, ans);
          deal<204 & 128>(nums[7], c, ans);
          break;
        };
        case 205: {
          deal<205 & 1>(nums[0], c, ans);
          deal<205 & 2>(nums[1], c, ans);
          deal<205 & 4>(nums[2], c, ans);
          deal<205 & 8>(nums[3], c, ans);
          deal<205 & 16>(nums[4], c, ans);
          deal<205 & 32>(nums[5], c, ans);
          deal<205 & 64>(nums[6], c, ans);
          deal<205 & 128>(nums[7], c, ans);
          break;
        };
        case 206: {
          deal<206 & 1>(nums[0], c, ans);
          deal<206 & 2>(nums[1], c, ans);
          deal<206 & 4>(nums[2], c, ans);
          deal<206 & 8>(nums[3], c, ans);
          deal<206 & 16>(nums[4], c, ans);
          deal<206 & 32>(nums[5], c, ans);
          deal<206 & 64>(nums[6], c, ans);
          deal<206 & 128>(nums[7], c, ans);
          break;
        };
        case 207: {
          deal<207 & 1>(nums[0], c, ans);
          deal<207 & 2>(nums[1], c, ans);
          deal<207 & 4>(nums[2], c, ans);
          deal<207 & 8>(nums[3], c, ans);
          deal<207 & 16>(nums[4], c, ans);
          deal<207 & 32>(nums[5], c, ans);
          deal<207 & 64>(nums[6], c, ans);
          deal<207 & 128>(nums[7], c, ans);
          break;
        };
        case 208: {
          deal<208 & 1>(nums[0], c, ans);
          deal<208 & 2>(nums[1], c, ans);
          deal<208 & 4>(nums[2], c, ans);
          deal<208 & 8>(nums[3], c, ans);
          deal<208 & 16>(nums[4], c, ans);
          deal<208 & 32>(nums[5], c, ans);
          deal<208 & 64>(nums[6], c, ans);
          deal<208 & 128>(nums[7], c, ans);
          break;
        };
        case 209: {
          deal<209 & 1>(nums[0], c, ans);
          deal<209 & 2>(nums[1], c, ans);
          deal<209 & 4>(nums[2], c, ans);
          deal<209 & 8>(nums[3], c, ans);
          deal<209 & 16>(nums[4], c, ans);
          deal<209 & 32>(nums[5], c, ans);
          deal<209 & 64>(nums[6], c, ans);
          deal<209 & 128>(nums[7], c, ans);
          break;
        };
        case 210: {
          deal<210 & 1>(nums[0], c, ans);
          deal<210 & 2>(nums[1], c, ans);
          deal<210 & 4>(nums[2], c, ans);
          deal<210 & 8>(nums[3], c, ans);
          deal<210 & 16>(nums[4], c, ans);
          deal<210 & 32>(nums[5], c, ans);
          deal<210 & 64>(nums[6], c, ans);
          deal<210 & 128>(nums[7], c, ans);
          break;
        };
        case 211: {
          deal<211 & 1>(nums[0], c, ans);
          deal<211 & 2>(nums[1], c, ans);
          deal<211 & 4>(nums[2], c, ans);
          deal<211 & 8>(nums[3], c, ans);
          deal<211 & 16>(nums[4], c, ans);
          deal<211 & 32>(nums[5], c, ans);
          deal<211 & 64>(nums[6], c, ans);
          deal<211 & 128>(nums[7], c, ans);
          break;
        };
        case 212: {
          deal<212 & 1>(nums[0], c, ans);
          deal<212 & 2>(nums[1], c, ans);
          deal<212 & 4>(nums[2], c, ans);
          deal<212 & 8>(nums[3], c, ans);
          deal<212 & 16>(nums[4], c, ans);
          deal<212 & 32>(nums[5], c, ans);
          deal<212 & 64>(nums[6], c, ans);
          deal<212 & 128>(nums[7], c, ans);
          break;
        };
        case 213: {
          deal<213 & 1>(nums[0], c, ans);
          deal<213 & 2>(nums[1], c, ans);
          deal<213 & 4>(nums[2], c, ans);
          deal<213 & 8>(nums[3], c, ans);
          deal<213 & 16>(nums[4], c, ans);
          deal<213 & 32>(nums[5], c, ans);
          deal<213 & 64>(nums[6], c, ans);
          deal<213 & 128>(nums[7], c, ans);
          break;
        };
        case 214: {
          deal<214 & 1>(nums[0], c, ans);
          deal<214 & 2>(nums[1], c, ans);
          deal<214 & 4>(nums[2], c, ans);
          deal<214 & 8>(nums[3], c, ans);
          deal<214 & 16>(nums[4], c, ans);
          deal<214 & 32>(nums[5], c, ans);
          deal<214 & 64>(nums[6], c, ans);
          deal<214 & 128>(nums[7], c, ans);
          break;
        };
        case 215: {
          deal<215 & 1>(nums[0], c, ans);
          deal<215 & 2>(nums[1], c, ans);
          deal<215 & 4>(nums[2], c, ans);
          deal<215 & 8>(nums[3], c, ans);
          deal<215 & 16>(nums[4], c, ans);
          deal<215 & 32>(nums[5], c, ans);
          deal<215 & 64>(nums[6], c, ans);
          deal<215 & 128>(nums[7], c, ans);
          break;
        };
        case 216: {
          deal<216 & 1>(nums[0], c, ans);
          deal<216 & 2>(nums[1], c, ans);
          deal<216 & 4>(nums[2], c, ans);
          deal<216 & 8>(nums[3], c, ans);
          deal<216 & 16>(nums[4], c, ans);
          deal<216 & 32>(nums[5], c, ans);
          deal<216 & 64>(nums[6], c, ans);
          deal<216 & 128>(nums[7], c, ans);
          break;
        };
        case 217: {
          deal<217 & 1>(nums[0], c, ans);
          deal<217 & 2>(nums[1], c, ans);
          deal<217 & 4>(nums[2], c, ans);
          deal<217 & 8>(nums[3], c, ans);
          deal<217 & 16>(nums[4], c, ans);
          deal<217 & 32>(nums[5], c, ans);
          deal<217 & 64>(nums[6], c, ans);
          deal<217 & 128>(nums[7], c, ans);
          break;
        };
        case 218: {
          deal<218 & 1>(nums[0], c, ans);
          deal<218 & 2>(nums[1], c, ans);
          deal<218 & 4>(nums[2], c, ans);
          deal<218 & 8>(nums[3], c, ans);
          deal<218 & 16>(nums[4], c, ans);
          deal<218 & 32>(nums[5], c, ans);
          deal<218 & 64>(nums[6], c, ans);
          deal<218 & 128>(nums[7], c, ans);
          break;
        };
        case 219: {
          deal<219 & 1>(nums[0], c, ans);
          deal<219 & 2>(nums[1], c, ans);
          deal<219 & 4>(nums[2], c, ans);
          deal<219 & 8>(nums[3], c, ans);
          deal<219 & 16>(nums[4], c, ans);
          deal<219 & 32>(nums[5], c, ans);
          deal<219 & 64>(nums[6], c, ans);
          deal<219 & 128>(nums[7], c, ans);
          break;
        };
        case 220: {
          deal<220 & 1>(nums[0], c, ans);
          deal<220 & 2>(nums[1], c, ans);
          deal<220 & 4>(nums[2], c, ans);
          deal<220 & 8>(nums[3], c, ans);
          deal<220 & 16>(nums[4], c, ans);
          deal<220 & 32>(nums[5], c, ans);
          deal<220 & 64>(nums[6], c, ans);
          deal<220 & 128>(nums[7], c, ans);
          break;
        };
        case 221: {
          deal<221 & 1>(nums[0], c, ans);
          deal<221 & 2>(nums[1], c, ans);
          deal<221 & 4>(nums[2], c, ans);
          deal<221 & 8>(nums[3], c, ans);
          deal<221 & 16>(nums[4], c, ans);
          deal<221 & 32>(nums[5], c, ans);
          deal<221 & 64>(nums[6], c, ans);
          deal<221 & 128>(nums[7], c, ans);
          break;
        };
        case 222: {
          deal<222 & 1>(nums[0], c, ans);
          deal<222 & 2>(nums[1], c, ans);
          deal<222 & 4>(nums[2], c, ans);
          deal<222 & 8>(nums[3], c, ans);
          deal<222 & 16>(nums[4], c, ans);
          deal<222 & 32>(nums[5], c, ans);
          deal<222 & 64>(nums[6], c, ans);
          deal<222 & 128>(nums[7], c, ans);
          break;
        };
        case 223: {
          deal<223 & 1>(nums[0], c, ans);
          deal<223 & 2>(nums[1], c, ans);
          deal<223 & 4>(nums[2], c, ans);
          deal<223 & 8>(nums[3], c, ans);
          deal<223 & 16>(nums[4], c, ans);
          deal<223 & 32>(nums[5], c, ans);
          deal<223 & 64>(nums[6], c, ans);
          deal<223 & 128>(nums[7], c, ans);
          break;
        };
        case 224: {
          deal<224 & 1>(nums[0], c, ans);
          deal<224 & 2>(nums[1], c, ans);
          deal<224 & 4>(nums[2], c, ans);
          deal<224 & 8>(nums[3], c, ans);
          deal<224 & 16>(nums[4], c, ans);
          deal<224 & 32>(nums[5], c, ans);
          deal<224 & 64>(nums[6], c, ans);
          deal<224 & 128>(nums[7], c, ans);
          break;
        };
        case 225: {
          deal<225 & 1>(nums[0], c, ans);
          deal<225 & 2>(nums[1], c, ans);
          deal<225 & 4>(nums[2], c, ans);
          deal<225 & 8>(nums[3], c, ans);
          deal<225 & 16>(nums[4], c, ans);
          deal<225 & 32>(nums[5], c, ans);
          deal<225 & 64>(nums[6], c, ans);
          deal<225 & 128>(nums[7], c, ans);
          break;
        };
        case 226: {
          deal<226 & 1>(nums[0], c, ans);
          deal<226 & 2>(nums[1], c, ans);
          deal<226 & 4>(nums[2], c, ans);
          deal<226 & 8>(nums[3], c, ans);
          deal<226 & 16>(nums[4], c, ans);
          deal<226 & 32>(nums[5], c, ans);
          deal<226 & 64>(nums[6], c, ans);
          deal<226 & 128>(nums[7], c, ans);
          break;
        };
        case 227: {
          deal<227 & 1>(nums[0], c, ans);
          deal<227 & 2>(nums[1], c, ans);
          deal<227 & 4>(nums[2], c, ans);
          deal<227 & 8>(nums[3], c, ans);
          deal<227 & 16>(nums[4], c, ans);
          deal<227 & 32>(nums[5], c, ans);
          deal<227 & 64>(nums[6], c, ans);
          deal<227 & 128>(nums[7], c, ans);
          break;
        };
        case 228: {
          deal<228 & 1>(nums[0], c, ans);
          deal<228 & 2>(nums[1], c, ans);
          deal<228 & 4>(nums[2], c, ans);
          deal<228 & 8>(nums[3], c, ans);
          deal<228 & 16>(nums[4], c, ans);
          deal<228 & 32>(nums[5], c, ans);
          deal<228 & 64>(nums[6], c, ans);
          deal<228 & 128>(nums[7], c, ans);
          break;
        };
        case 229: {
          deal<229 & 1>(nums[0], c, ans);
          deal<229 & 2>(nums[1], c, ans);
          deal<229 & 4>(nums[2], c, ans);
          deal<229 & 8>(nums[3], c, ans);
          deal<229 & 16>(nums[4], c, ans);
          deal<229 & 32>(nums[5], c, ans);
          deal<229 & 64>(nums[6], c, ans);
          deal<229 & 128>(nums[7], c, ans);
          break;
        };
        case 230: {
          deal<230 & 1>(nums[0], c, ans);
          deal<230 & 2>(nums[1], c, ans);
          deal<230 & 4>(nums[2], c, ans);
          deal<230 & 8>(nums[3], c, ans);
          deal<230 & 16>(nums[4], c, ans);
          deal<230 & 32>(nums[5], c, ans);
          deal<230 & 64>(nums[6], c, ans);
          deal<230 & 128>(nums[7], c, ans);
          break;
        };
        case 231: {
          deal<231 & 1>(nums[0], c, ans);
          deal<231 & 2>(nums[1], c, ans);
          deal<231 & 4>(nums[2], c, ans);
          deal<231 & 8>(nums[3], c, ans);
          deal<231 & 16>(nums[4], c, ans);
          deal<231 & 32>(nums[5], c, ans);
          deal<231 & 64>(nums[6], c, ans);
          deal<231 & 128>(nums[7], c, ans);
          break;
        };
        case 232: {
          deal<232 & 1>(nums[0], c, ans);
          deal<232 & 2>(nums[1], c, ans);
          deal<232 & 4>(nums[2], c, ans);
          deal<232 & 8>(nums[3], c, ans);
          deal<232 & 16>(nums[4], c, ans);
          deal<232 & 32>(nums[5], c, ans);
          deal<232 & 64>(nums[6], c, ans);
          deal<232 & 128>(nums[7], c, ans);
          break;
        };
        case 233: {
          deal<233 & 1>(nums[0], c, ans);
          deal<233 & 2>(nums[1], c, ans);
          deal<233 & 4>(nums[2], c, ans);
          deal<233 & 8>(nums[3], c, ans);
          deal<233 & 16>(nums[4], c, ans);
          deal<233 & 32>(nums[5], c, ans);
          deal<233 & 64>(nums[6], c, ans);
          deal<233 & 128>(nums[7], c, ans);
          break;
        };
        case 234: {
          deal<234 & 1>(nums[0], c, ans);
          deal<234 & 2>(nums[1], c, ans);
          deal<234 & 4>(nums[2], c, ans);
          deal<234 & 8>(nums[3], c, ans);
          deal<234 & 16>(nums[4], c, ans);
          deal<234 & 32>(nums[5], c, ans);
          deal<234 & 64>(nums[6], c, ans);
          deal<234 & 128>(nums[7], c, ans);
          break;
        };
        case 235: {
          deal<235 & 1>(nums[0], c, ans);
          deal<235 & 2>(nums[1], c, ans);
          deal<235 & 4>(nums[2], c, ans);
          deal<235 & 8>(nums[3], c, ans);
          deal<235 & 16>(nums[4], c, ans);
          deal<235 & 32>(nums[5], c, ans);
          deal<235 & 64>(nums[6], c, ans);
          deal<235 & 128>(nums[7], c, ans);
          break;
        };
        case 236: {
          deal<236 & 1>(nums[0], c, ans);
          deal<236 & 2>(nums[1], c, ans);
          deal<236 & 4>(nums[2], c, ans);
          deal<236 & 8>(nums[3], c, ans);
          deal<236 & 16>(nums[4], c, ans);
          deal<236 & 32>(nums[5], c, ans);
          deal<236 & 64>(nums[6], c, ans);
          deal<236 & 128>(nums[7], c, ans);
          break;
        };
        case 237: {
          deal<237 & 1>(nums[0], c, ans);
          deal<237 & 2>(nums[1], c, ans);
          deal<237 & 4>(nums[2], c, ans);
          deal<237 & 8>(nums[3], c, ans);
          deal<237 & 16>(nums[4], c, ans);
          deal<237 & 32>(nums[5], c, ans);
          deal<237 & 64>(nums[6], c, ans);
          deal<237 & 128>(nums[7], c, ans);
          break;
        };
        case 238: {
          deal<238 & 1>(nums[0], c, ans);
          deal<238 & 2>(nums[1], c, ans);
          deal<238 & 4>(nums[2], c, ans);
          deal<238 & 8>(nums[3], c, ans);
          deal<238 & 16>(nums[4], c, ans);
          deal<238 & 32>(nums[5], c, ans);
          deal<238 & 64>(nums[6], c, ans);
          deal<238 & 128>(nums[7], c, ans);
          break;
        };
        case 239: {
          deal<239 & 1>(nums[0], c, ans);
          deal<239 & 2>(nums[1], c, ans);
          deal<239 & 4>(nums[2], c, ans);
          deal<239 & 8>(nums[3], c, ans);
          deal<239 & 16>(nums[4], c, ans);
          deal<239 & 32>(nums[5], c, ans);
          deal<239 & 64>(nums[6], c, ans);
          deal<239 & 128>(nums[7], c, ans);
          break;
        };
        case 240: {
          deal<240 & 1>(nums[0], c, ans);
          deal<240 & 2>(nums[1], c, ans);
          deal<240 & 4>(nums[2], c, ans);
          deal<240 & 8>(nums[3], c, ans);
          deal<240 & 16>(nums[4], c, ans);
          deal<240 & 32>(nums[5], c, ans);
          deal<240 & 64>(nums[6], c, ans);
          deal<240 & 128>(nums[7], c, ans);
          break;
        };
        case 241: {
          deal<241 & 1>(nums[0], c, ans);
          deal<241 & 2>(nums[1], c, ans);
          deal<241 & 4>(nums[2], c, ans);
          deal<241 & 8>(nums[3], c, ans);
          deal<241 & 16>(nums[4], c, ans);
          deal<241 & 32>(nums[5], c, ans);
          deal<241 & 64>(nums[6], c, ans);
          deal<241 & 128>(nums[7], c, ans);
          break;
        };
        case 242: {
          deal<242 & 1>(nums[0], c, ans);
          deal<242 & 2>(nums[1], c, ans);
          deal<242 & 4>(nums[2], c, ans);
          deal<242 & 8>(nums[3], c, ans);
          deal<242 & 16>(nums[4], c, ans);
          deal<242 & 32>(nums[5], c, ans);
          deal<242 & 64>(nums[6], c, ans);
          deal<242 & 128>(nums[7], c, ans);
          break;
        };
        case 243: {
          deal<243 & 1>(nums[0], c, ans);
          deal<243 & 2>(nums[1], c, ans);
          deal<243 & 4>(nums[2], c, ans);
          deal<243 & 8>(nums[3], c, ans);
          deal<243 & 16>(nums[4], c, ans);
          deal<243 & 32>(nums[5], c, ans);
          deal<243 & 64>(nums[6], c, ans);
          deal<243 & 128>(nums[7], c, ans);
          break;
        };
        case 244: {
          deal<244 & 1>(nums[0], c, ans);
          deal<244 & 2>(nums[1], c, ans);
          deal<244 & 4>(nums[2], c, ans);
          deal<244 & 8>(nums[3], c, ans);
          deal<244 & 16>(nums[4], c, ans);
          deal<244 & 32>(nums[5], c, ans);
          deal<244 & 64>(nums[6], c, ans);
          deal<244 & 128>(nums[7], c, ans);
          break;
        };
        case 245: {
          deal<245 & 1>(nums[0], c, ans);
          deal<245 & 2>(nums[1], c, ans);
          deal<245 & 4>(nums[2], c, ans);
          deal<245 & 8>(nums[3], c, ans);
          deal<245 & 16>(nums[4], c, ans);
          deal<245 & 32>(nums[5], c, ans);
          deal<245 & 64>(nums[6], c, ans);
          deal<245 & 128>(nums[7], c, ans);
          break;
        };
        case 246: {
          deal<246 & 1>(nums[0], c, ans);
          deal<246 & 2>(nums[1], c, ans);
          deal<246 & 4>(nums[2], c, ans);
          deal<246 & 8>(nums[3], c, ans);
          deal<246 & 16>(nums[4], c, ans);
          deal<246 & 32>(nums[5], c, ans);
          deal<246 & 64>(nums[6], c, ans);
          deal<246 & 128>(nums[7], c, ans);
          break;
        };
        case 247: {
          deal<247 & 1>(nums[0], c, ans);
          deal<247 & 2>(nums[1], c, ans);
          deal<247 & 4>(nums[2], c, ans);
          deal<247 & 8>(nums[3], c, ans);
          deal<247 & 16>(nums[4], c, ans);
          deal<247 & 32>(nums[5], c, ans);
          deal<247 & 64>(nums[6], c, ans);
          deal<247 & 128>(nums[7], c, ans);
          break;
        };
        case 248: {
          deal<248 & 1>(nums[0], c, ans);
          deal<248 & 2>(nums[1], c, ans);
          deal<248 & 4>(nums[2], c, ans);
          deal<248 & 8>(nums[3], c, ans);
          deal<248 & 16>(nums[4], c, ans);
          deal<248 & 32>(nums[5], c, ans);
          deal<248 & 64>(nums[6], c, ans);
          deal<248 & 128>(nums[7], c, ans);
          break;
        };
        case 249: {
          deal<249 & 1>(nums[0], c, ans);
          deal<249 & 2>(nums[1], c, ans);
          deal<249 & 4>(nums[2], c, ans);
          deal<249 & 8>(nums[3], c, ans);
          deal<249 & 16>(nums[4], c, ans);
          deal<249 & 32>(nums[5], c, ans);
          deal<249 & 64>(nums[6], c, ans);
          deal<249 & 128>(nums[7], c, ans);
          break;
        };
        case 250: {
          deal<250 & 1>(nums[0], c, ans);
          deal<250 & 2>(nums[1], c, ans);
          deal<250 & 4>(nums[2], c, ans);
          deal<250 & 8>(nums[3], c, ans);
          deal<250 & 16>(nums[4], c, ans);
          deal<250 & 32>(nums[5], c, ans);
          deal<250 & 64>(nums[6], c, ans);
          deal<250 & 128>(nums[7], c, ans);
          break;
        };
        case 251: {
          deal<251 & 1>(nums[0], c, ans);
          deal<251 & 2>(nums[1], c, ans);
          deal<251 & 4>(nums[2], c, ans);
          deal<251 & 8>(nums[3], c, ans);
          deal<251 & 16>(nums[4], c, ans);
          deal<251 & 32>(nums[5], c, ans);
          deal<251 & 64>(nums[6], c, ans);
          deal<251 & 128>(nums[7], c, ans);
          break;
        };
        case 252: {
          deal<252 & 1>(nums[0], c, ans);
          deal<252 & 2>(nums[1], c, ans);
          deal<252 & 4>(nums[2], c, ans);
          deal<252 & 8>(nums[3], c, ans);
          deal<252 & 16>(nums[4], c, ans);
          deal<252 & 32>(nums[5], c, ans);
          deal<252 & 64>(nums[6], c, ans);
          deal<252 & 128>(nums[7], c, ans);
          break;
        };
        case 253: {
          deal<253 & 1>(nums[0], c, ans);
          deal<253 & 2>(nums[1], c, ans);
          deal<253 & 4>(nums[2], c, ans);
          deal<253 & 8>(nums[3], c, ans);
          deal<253 & 16>(nums[4], c, ans);
          deal<253 & 32>(nums[5], c, ans);
          deal<253 & 64>(nums[6], c, ans);
          deal<253 & 128>(nums[7], c, ans);
          break;
        };
        case 254: {
          deal<254 & 1>(nums[0], c, ans);
          deal<254 & 2>(nums[1], c, ans);
          deal<254 & 4>(nums[2], c, ans);
          deal<254 & 8>(nums[3], c, ans);
          deal<254 & 16>(nums[4], c, ans);
          deal<254 & 32>(nums[5], c, ans);
          deal<254 & 64>(nums[6], c, ans);
          deal<254 & 128>(nums[7], c, ans);
          break;
        };
        case 255: {
          deal<255 & 1>(nums[0], c, ans);
          deal<255 & 2>(nums[1], c, ans);
          deal<255 & 4>(nums[2], c, ans);
          deal<255 & 8>(nums[3], c, ans);
          deal<255 & 16>(nums[4], c, ans);
          deal<255 & 32>(nums[5], c, ans);
          deal<255 & 64>(nums[6], c, ans);
          deal<255 & 128>(nums[7], c, ans);
          break;
        };
      }
    }
    ans %= mod;
    printf("%d\n", (int)(ans % mod));
  }
  fflush(stdout);
  exit(0);
}