use std::collections::BTreeMap;

use proconio::input;

fn main() {
    input!(n: i64, q: usize);

    // ranges[&l] = (r, a, b)
    let mut ranges = BTreeMap::new();
    ranges.insert(1, (n + 1, 1, 0));

    for _ in 0 .. q {
        // eprintln!("*ranges = {:?}", ranges);

        input!(t: usize);
        if t == 1 {
            input!(x: i64);

            let (_l, &(_r, a, b)) = ranges.range(..= x).next_back().unwrap();

            // eprintln!("query1({x}): [{_l},{_r})-{a}-{b} ==> {}", (x - a).abs() + b);

            println!("{}", (x - a).abs() + b);
        } else {
            input!(a: i64, b: i64);

            {
                let (&_l1, &(_r1, a1, b1)) = ranges.range(..= a).next_back().unwrap();
                let cost_current = (a - a1).abs() + b1;
                if cost_current <= b {
                    // eprintln!("query2({a}, {b}): skipped because of [{_l1},{_r1})-{a1}-{b1}");
                    continue;
                }
            }

            // eprintln!("query2({a}, {b}):");

            let mut l = 1;
            let mut r = n + 1;

            // set left bound
            while let Some((&l1, &(_r1, a1, b1))) = ranges.range(..= a).next_back() {
                if (a1 - a).abs() + b <= b1 {
                    l = l1;
                    ranges.remove(&l1);
                    // eprintln!("    L: removed [{l1},{_r1})-{a1}-{b1}");
                    continue;
                }

                l = (a + a1 + b - b1) / 2;
                ranges.insert(l1, (l, a1, b1));
                // eprintln!("    L: updated [{l1},{_r1})-{a1}-{b1} ==> [{l1},{l})");
                break;
            }

            // set right bound
            while let Some((&l1, &(r1, a1, b1))) = ranges.range(a ..).next() {
                if (a1 - a).abs() + b <= b1 {
                    r = r1;
                    ranges.remove(&l1);
                    // eprintln!("    R: removed [{l1},{r1})-{a1}-{b1}");
                    continue;
                }

                r = (a + a1 - b + b1) / 2;
                ranges.remove(&l1);
                ranges.insert(r, (r1, a1, b1));
                // eprintln!("    R: updated [{l1},{r1})-{a1}-{b1} ==> [{r},{r1})");
            }

            ranges.insert(l, (r, a, b));
            // eprintln!("    inserted [{l},{r})-{a}-{b}");
        }
    }
}