进

#include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>

using namespace std;

// 浮点精度容错（信奥标准值）
const double EPS = 1e-9;
const double END_POS = 1000.0;

struct Event {
char type; // 'T' 或 'D'
int val; // T的S值 / D的X值
bool processed; // 是否已触发
};

int main() {
int N;
cin >> N;

vector<Event> events;
for (int i = 0; i < N; ++i) {
    char type;
    int val;
    cin >> type >> val;
    events.push_back({type, val, false});
}

// 核心状态变量（全程用double保证精度）
double current_time = 0.0;
double current_pos = 0.0;
int mistake_count = 0;
double speed = 1.0; // 初始速度 1m/s

// 循环终止条件：当前位置 ≥ 终点（带精度容错）
while (current_pos < END_POS - EPS) {
    // 第一步：遍历所有未处理事件，计算「实际触发时间」
    vector<pair<double, int>> valid_events; // (触发时间, 事件索引)
    for (int i = 0; i < events.size(); ++i) {
        if (events[i].processed) continue;

        double trigger_time = -1.0;
        if (events[i].type == 'T') {
            // T类型：触发时间固定为val，需判断是否未过期且未超终点
            int S = events[i].val;
            if (S < current_time - EPS) continue; // 时间已过期

            // 计算T时刻的位置（当前速度下）
            double pos_at_T = current_pos + speed * (S - current_time);
            if (pos_at_T > END_POS + EPS) continue; // T时刻已超终点

            trigger_time = S;
        } else { // D类型
            // D类型：触发位置固定为val，需判断是否未过期
            int X = events[i].val;
            if (X < current_pos - EPS) continue; // 位置已过期
            if (X > END_POS + EPS) continue;     // 位置超终点

            // 计算到达X的时间（当前速度下）
            trigger_time = current_time + (X - current_pos) / speed;
        }

        if (trigger_time > 0) { // 有效事件
            valid_events.emplace_back(trigger_time, i);
        }
    }

    // 第二步：计算「到终点的剩余时间」
    double time_to_end = (END_POS - current_pos) / speed;
    double end_time = current_time + time_to_end;

    // 第三步：确定「下一个目标时间」（事件 or 终点）
    double next_time = end_time; // 默认滑到终点
    vector<int> events_to_process; // 需批量处理的事件索引

    if (!valid_events.empty()) {
        // 按触发时间排序，找最早的事件时间
        sort(valid_events.begin(), valid_events.end());
        double earliest_event_time = valid_events[0].first;

        // 收集所有「同一时刻触发」的事件（浮点容错）
        for (auto& ve : valid_events) {
            if (ve.first < earliest_event_time + EPS) {
                events_to_process.push_back(ve.second);
            } else {
                break; // 排序后，后续事件时间更大
            }
        }

        // 若事件时间早于/等于终点时间，优先处理事件
        if (earliest_event_time < end_time + EPS) {
            next_time = earliest_event_time;
        }
    }

    // 第四步：滑行到「下一个目标时间」（钳位到终点）
    double delta_t = next_time - current_time;
    double delta_p = speed * delta_t;
    // 确保不滑过终点
    current_pos = min(current_pos + delta_p, END_POS);
    current_time = next_time;

    // 第五步：处理触发的事件（批量更新失误次数）
    for (int idx : events_to_process) {
        events[idx].processed = true;
        mistake_count++;
    }

    // 第六步：更新速度（失误次数变化后）
    speed = 1.0 / (mistake_count + 1);
}

// 四舍五入输出（信奥标准写法）
cout << (int)(current_time + 0.5) << endl;

return 0;

}