#include <bits/stdc++.h>
using namespace std;
 
map<char,int>myMap;
int basketball,calligraphy;

//日期是否合法模板
int months[13] = {0,31,28,31,30,31,30,31,31,30,31,30,31};
bool check(int date)
{
    int year=date/10000,month=date%10000/100,day=date%100;
    
    if(!month||month>=13||!day)return false;
    if(month!=2&&day>months[month])return false;
    if(month==2)
    {
        int leap=(year%100!=0&&year%4==0)||year%400==0;
        if(day>28+leap)return false;
    }
    return true;
}


int main() 
{
     // 插入数字与笔画数
    myMap['0'] = 13;
    myMap['1'] = 1;
    myMap['2'] = 2;
    myMap['3'] = 3;
    myMap['4'] = 5;
    myMap['5'] = 4;
    myMap['6'] = 4;
    myMap['7'] = 2;
    myMap['8'] = 2;
    myMap['9'] = 2;
    
      // 遍历日期范围，从2000年1月1日到2024年4月13日
    for(int i=20000101;i<=20240413;i++)
    {
        if(check(i))
        {
            string s=to_string(i);
            int num=0;
            for(auto j:s)
            {
                num+=myMap[j];
            }
            if(num>50)
            {
                basketball++;
            }
        }
       
       
    }
    cout<<basketball;
    return 0;
}

#include <bits/stdc++.h>
using namespace std;

static const long long MAX_VAL = 1000000000000LL; // 1e12

// 预先生成所有在 [1, 1e12] 范围内 "十六进制由同一数字重复" 的幸运数字
// 注意：digit 取值范围是 [0..15]，长度取值范围适当即可（1~16足够覆盖1e12）
vector<long long> generateLuckyNumbers() {
    vector<long long> luckyNums;
    // 十六进制最大可用字符：0~f (共16个)
    for (int digit = 0; digit < 16; ++digit) {
        for (int length = 1; length <= 16; ++length) {
            // 构建长度为 length 的重复字符
            // 例如若 digit = 12 (十六进制 c)，length = 4，则是"cccc"
            // 然后转为十进制，判断是否 <= 1e12
            // digit 转成对应的16进制字符
            char hexDigit;
            if (digit < 10) {
                hexDigit = char(digit + '0');
            } else {
                hexDigit = char(digit - 10 + 'a');
            }

            // 构建重复串
            string hexStr(length, hexDigit);

            // 转成十进制
            // stoll(hexStr, nullptr, 16) 有可能超范围，用更安全方式
            // 这里用 64位整型计算
            long long num = 0;
            for (char c : hexStr) {
                // digitVal 可以用 c - '0' 或 c - 'a' + 10
                // 但我们已经知道是同一个字符
                int val;
                if (isdigit(c))
                    val = c - '0';
                else
                    val = c - 'a' + 10;
                num = num * 16 + val;

                // 若已经超过范围就中断
                if (num > MAX_VAL) break;
            }

            if (num > 0 && num <= MAX_VAL) {
                luckyNums.push_back(num);
            }
        }
    }
    // 去重并排序
    sort(luckyNums.begin(), luckyNums.end());
    luckyNums.erase(unique(luckyNums.begin(), luckyNums.end()), luckyNums.end());
    return luckyNums;
}

int main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    // 预先生成所有可能的幸运数字
    static vector<long long> luckyNumbers = generateLuckyNumbers();

    int T;
    cin >> T;
    while (T--) {
        long long l, r;
        cin >> l >> r;
        // 在 luckyNumbers 中，用二分查找统计区间 [l, r] 内的元素个数
        auto leftIt = lower_bound(luckyNumbers.begin(), luckyNumbers.end(), l);
        auto rightIt = upper_bound(luckyNumbers.begin(), luckyNumbers.end(), r);
        cout << (rightIt - leftIt) << "\n";
    }
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;

int n, m;
int cnt1 = 0, cnt2 = 0;
int a[N], b[N];

int main() {
    cin >> n >> m;

    // 输入怪物的战斗时间，并统计需要时间1和时间2的怪物数量
    for (int i = 1; i <= n; i++) {
        int x;
        cin >> x;
        if (x == 1) {
            cnt1++;
        } else {
            cnt2++;
        }
    }

    // 输入时间段的长度
    for (int i = 1; i <= m; i++) {
        cin >> b[i];
    }

    // 对时间段进行降序排序
    sort(b + 1, b + 1 + m, [](int u, int v) { return u > v; });

    // 优先使用时间段消灭需要时间2的怪物
    for (int i = 1; i <= m && cnt2 > 0; i++) {
        if (b[i] >= 2) {  // 如果时间段长度>=2，可以消灭一个需要时间2的怪物
            int x = min(cnt2, b[i] / 2);  // 计算能消灭多少个怪物
            cnt2 -= x;  // 更新需要消灭时间2的怪物数量
        }
    }

    // 使用剩余的时间段消灭需要时间1的怪物
    for (int i = 1; i <= m && cnt1 > 0; i++) {
        if (b[i] >= 1) {  // 如果时间段长度>=1，可以消灭一个需要时间1的怪物
            int x = min(cnt1, b[i]);  // 计算能消灭多少个怪物
            cnt1 -= x;  // 更新需要消灭时间1的怪物数量
        }
    }

    // 判断是否所有怪物都被消灭
    if (cnt1 == 0 && cnt2 == 0) {
        cout << "Y" << endl;
    } else {
        cout << "N" << endl;
    }

    return 0;
}

#include <bits/stdc++.h>
using namespace std;

/*
    问题描述：
    给定若干组输入 (x, y)，表示有 x 头奶牛，其挤奶产量为 y。
    这些 input 的 x 之和为 M（总奶牛数，且 M 为偶数）。
    将所有 M 头奶牛分成 M/2 对，并行挤奶时的总耗时，取决于所有配对 (A, B) 的挤奶时间 A+B 的最大值。
    目标是找到所有可能配对中，使 max(A+B) 最小的方案，并输出这个值。

    解决思路（双指针）：
    1. 将每种产量 y 与其数量 x 记录下来，并按照 y 升序排序。
    2. 设置两端指针：left 指向最小产量，right 指向最大产量。
    3. 每次取尽可能多的奶牛对，数量为 min(左侧剩余奶牛数, 右侧剩余奶牛数)。
    4. 该批次配对的时间为 left 产量 + right 产量，用其更新全局最大值。
    5. 逐步减少两侧数量并移动指针，直至全部奶牛被配对完成。

    时间复杂度主要在对产量排序上，为 O(N log N)，其中 N 最多为 100000（不按单头奶牛数量计）。
*/

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int N;
    cin >> N;

    // 记录 (y, x)
    vector<pair<long long, long long>> cows;
    cows.reserve(N);

    long long totalCount = 0; // 用于计算奶牛总数 M
    for (int i = 0; i < N; ++i) {
        long long x, y;
        cin >> x >> y;
        cows.push_back({y, x});
        totalCount += x;
    }

    // 按产量升序排序
    sort(cows.begin(), cows.end(), [](auto &a, auto &b){
        return a.first < b.first;
    });

    // 双指针：l 指向产量最小，r 指向产量最大
    int l = 0, r = (int)cows.size() - 1;
    long long res = 0;

    while (l <= r) {
        if (l == r) {
            // 剩余都在同一个产量上
            // 这时必然剩余的奶牛数为偶数，可以两两配对
            // 配对时间为 2 * cows[l].first
            // 但实际只需要一次就能给出最终答案
            res = max(res, 2LL * cows[l].first);
            break;
        }

        // 本轮可以配对的奶牛数
        long long num = min(cows[l].second, cows[r].second);
        // 对应配对时间
        long long sumTime = cows[l].first + cows[r].first;
        res = max(res, sumTime);

        // 扣除配对过的奶牛数
        cows[l].second -= num;
        cows[r].second -= num;

        // 如果左侧产量用完，则左指针右移
        if (cows[l].second == 0) {
            ++l;
        }
        // 如果右侧产量用完，则右指针左移
        if (cows[r].second == 0) {
            --r;
        }
    }

    cout << res << "\n";
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 1e5 + 10;


// h[] 用于存储每栋大楼的高度
// t[] 用于存储不同查询日的海平面高度
// st[] 用于标记某栋大楼今日是否仍未被淹没
vector<int> h(N);
vector<int> t(N);
bool st[N];

int main() {

    int n, d;
    // 输入 n（大楼数量）和 d（查询天数）
    cin >> n >> d;
    // 读取大楼高度
    for (int i = 1; i <= n; i++) {
        cin >> h[i];
    }
    // 读取查询海平面天数数组
    for (int i = 1; i <= d; i++) {
        cin >> t[i];
    }

    // 将 st[] 初始化为 true，表示初始默认所有大楼都未被淹没
    memset(st, true, sizeof(st));

    // 对每个查询天数分别进行处理
    int region = 0;  // 表示当前查询日下，未淹没大楼所形成的区域数量
    for (int i = 1; i <= d; i++) {
        int day = t[i];    // 当前海平面高度
        region = 0;        // 每次查询前重置区域数
        bool flag = false; // 标记是否在扫描大楼时已经遇到一个“连续未淹没区域”

        // 1) 更新 st[j]: 若大楼高度 <= 当前海平面，则标记为已被淹没 (false)
        for (int j = 1; j <= n; j++) {
            if (h[j] <= day) {
                st[j] = false;
            }
        }

        // 2) 统计当前未淹没楼形成的连续区域数
        for (int j = 1; j <= n; j++) {
            if (st[j]) {
                // 如果此楼未淹没并且尚未记录一个新区域，则区域数加一
                if (!flag) {
                    region++;
                    flag = true;  // 进入新区域
                }
            } else {
                // 如果此楼已被淹没，则结束之前的未淹没区域标记
                flag = false;
            }
        }
        // 输出当日的区域数
        cout << region << " ";
    }
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 1e5 + 10;

bool st[N];
int main() {

    int n, d;
    cin >> n >> d;
    
    vector<pair<int,int>>h(n+1);// h[]数组存储(大楼高度, 其原始下标)，下标从1开始使用
    for (int i = 1; i <= n; i++) 
    {
        cin>>h[i].first;// 读入大楼高度
        h[i].second=i; // 存储对应的原始位置
    }
    
    
    // t[]数组存储每个查询的海平面高度(总共有d次查询)
     vector<int> t(d);
    for (int i = 0; i < d; i++) 
    {
        cin >> t[i]; // 读入第i次查询的海平面高度
    }

     // 将 h 中的大楼数据按高度升序进行排序
    sort(h.begin() + 1, h.end());
    
    // drown[i]存储在第i次查询中「新被淹没」的大楼下标
    vector<vector<int>>drown(d);
    
    // 双指针：i遍历查询，j遍历大楼列表
    // 若 h[j+1].first <= t[i] => 说明该楼在第i次查询时已经被淹没
    // 则记录其位置到drown[i]中表示本轮新增被淹没的楼
    for (int i = 0, j = 0; i < d; i++) {
        while (j + 1 <= n && h[j + 1].first <= t[i]) {
            j++;
            drown[i].emplace_back(h[j].second);
        }
    }
    
    // st[x]用于标记下标为x的楼是否已被淹没
    // 在边界0和n+1处设置为true，方便判断左右是否淹没
    st[0] = true;      // 边界视为已淹没
    st[n + 1] = true;  // 边界视为已淹没

    int ans = 1;        // 当前未淹没的大楼形成的区域数，初始设为1
    
     // 遍历每个查询，将在该日新增被淹没的楼进行处理
    for(auto &u:drown)
    {
        // u中存储了本次查询“刚好在海平面下”的大楼索引
        for(auto x:u)
        {
             // 情况1：若左右都未被淹，则淹没x会把一个连续区域分成两部分 => 区域数 +1
            if(!st[x-1]&&!st[x+1])
            {
                ans+=1;
            }
            
             // 情况2：若左右都已淹，则淹没x会将两个淹没区“连接”，相当于减少一个区域 => 区域数 -1
            if (st[x - 1] && st[x + 1]) {
                ans -= 1;
            }
            st[x]=true;
        }
        cout<<ans<<" ";
    }
    return 0;
}