#include <bits/stdc++.h>
using namespace std;
template <class T, class U>
void ckmin(T &a, U b) {
  if (a > b) a = b;
}
template <class T, class U>
void ckmax(T &a, U b) {
  if (a < b) a = b;
}
const long double EPS = 1e-12;
int Q;
struct node {
  long long pos, v, len, stor, best;
  int pri, subt;
  node *ch[2];
  node(long long x, long long d, long long sp) {
    pos = x;
    len = d;
    v = sp;
    stor = v * d;
    best = min(0ll, stor);
    pri = rand();
    ch[0] = ch[1] = nullptr;
    subt = 1;
  }
};
void recalc(node *t) {
  if (!t) return;
  t->stor = t->v * t->len;
  t->subt = 1;
  if (t->ch[0] && t->ch[1]) {
    t->stor += t->ch[0]->stor + t->ch[1]->stor;
    t->subt += t->ch[0]->subt + t->ch[1]->subt;
    t->best =
        min(t->ch[0]->best, t->ch[0]->stor + t->v * t->len + t->ch[1]->best);
  } else if (t->ch[1]) {
    t->stor += t->ch[1]->stor;
    t->subt += t->ch[1]->subt;
    t->best = min(0ll, t->v * t->len + t->ch[1]->best);
  } else if (t->ch[0]) {
    t->stor += t->ch[0]->stor;
    t->subt += t->ch[0]->subt;
    t->best = min(t->ch[0]->best, t->ch[0]->stor + t->v * t->len);
  } else {
    t->best = min(0ll, t->v * t->len);
  }
}
node *merge(node *l, node *r) {
  if (!l) return r;
  if (!r) return l;
  if (l->pri > r->pri) {
    l->ch[1] = merge(l->ch[1], r);
    recalc(l);
    return l;
  } else {
    r->ch[0] = merge(l, r->ch[0]);
    recalc(r);
    return r;
  }
}
typedef pair<node *, node *> pnn;
pnn split(node *t, long long x, bool flag) {
  if (!t) return {nullptr, nullptr};
  long long cur = (flag ? (t->ch[0] ? t->ch[0]->subt : 0) : t->pos);
  if (x <= cur) {
    pnn p = split(t->ch[0], x, flag);
    t->ch[0] = p.second;
    recalc(t);
    return {p.first, t};
  } else {
    pnn p = split(t->ch[1], (flag ? x - cur - 1 : x), flag);
    t->ch[1] = p.first;
    recalc(t);
    return {t, p.second};
  }
}
long double trav(node *t, long long x) {
  long long cur = (t->ch[0] ? t->ch[0]->best : 1000000007);
  if (cur <= x) {
    return trav(t->ch[0], x);
  }
  x -= (t->ch[0] ? t->ch[0]->stor : 0);
  if (t->v * t->len <= x) {
    return t->pos + (1.0 * x / (t->v));
  } else {
    return trav(t->ch[1], x - t->v * t->len);
  }
}
void inorder(node *t) {
  if (!t) return;
  inorder(t->ch[0]);
  cout << "NODE pos " << t->pos << " velocity " << t->v << " dist " << t->len
       << endl;
  inorder(t->ch[1]);
}
node *root;
set<long long> times;
int32_t main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  cout << fixed << setprecision(12);
  cerr << fixed << setprecision(4);
  srand(69);
  root = merge(new node(0, 1000000007, 0),
               merge(new node(1000000007, 1000000007, -1000000007),
                     new node(2 * 1000000007, 1000000007, -1000000007)));
  times.insert(0);
  times.insert(1000000007);
  times.insert(2 * 1000000007);
  cin >> Q;
  for (auto i = (0); i < (Q); i++) {
    int qid;
    cin >> qid;
    if (qid == 1) {
      long long t, s, len;
      cin >> t >> s;
      len = *times.upper_bound(t) - t;
      times.insert(t);
      pnn p = split(root, t, false);
      int zz = (p.first->subt) - 1;
      pnn lt = split(p.first, zz, true);
      lt.second->len = t - lt.second->pos;
      lt.second->stor = lt.second->v * lt.second->len;
      lt.second->best = min(0ll, lt.second->stor);
      root = merge(merge(lt.first, lt.second),
                   merge(new node(t, len, s), p.second));
    }
    if (qid == 2) {
      long long t;
      cin >> t;
      times.erase(t);
      pnn p = split(root, t, false);
      pnn p1 = split(p.second, t + 1, false);
      int zz = (p.first->subt) - 1;
      pnn lt = split(p.first, zz, true);
      lt.second->len = *times.upper_bound(t) - lt.second->pos;
      lt.second->stor = lt.second->v * lt.second->len;
      lt.second->best = min(0ll, lt.second->stor);
      root = merge(merge(lt.first, lt.second), p1.second);
    }
    if (qid == 3) {
      long long l, r, v;
      cin >> l >> r >> v;
      if (v <= 0) {
        cout << l << '\n';
        continue;
      }
      pnn p = split(root, l, false);
      long double ans = trav(p.second, -v);
      if (ans > r + EPS) {
        cout << "-1\n";
      } else {
        cout << ans << '\n';
      }
      root = merge(p.first, p.second);
    }
  }
  return 0;
}
