```go
package main

import (
	"bufio"
	"fmt"
	"os"
)

type Interval struct {
	l, r int64
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	var n int
	fmt.Fscan(reader, &n)

	intervals := make([]Interval, 0)

	for i := 0; i < n; i++ {
		var t int
		var l, r int64
		fmt.Fscan(reader, &t, &l, &r)

		switch t {
		case 1:
			intervals = addInterval(intervals, l, r)
		case 2:
			intervals = removeInterval(intervals, l, r)
		case 3:
			intervals = invertInterval(intervals, l, r)
		}

		fmt.Fprintln(writer, findMEX(intervals))
	}
}

func addInterval(intervals []Interval, l, r int64) []Interval {
	result := make([]Interval, 0)
	i := 0

	for i < len(intervals) && intervals[i].r < l-1 {
		result = append(result, intervals[i])
		i++
	}

	for i < len(intervals) && intervals[i].l <= r+1 {
		l = min(l, intervals[i].l)
		r = max(r, intervals[i].r)
		i++
	}

	result = append(result, Interval{l, r})

	for i < len(intervals) {
		result = append(result, intervals[i])
		i++
	}

	return result
}

func removeInterval(intervals []Interval, l, r int64) []Interval {
	result := make([]Interval, 0)

	for _, iv := range intervals {
		if iv.r < l || iv.l > r {
			result = append(result, iv)
		} else {
			if iv.l < l {
				result = append(result, Interval{iv.l, l - 1})
			}
			if iv.r > r {
				result = append(result, Interval{r + 1, iv.r})
			}
		}
	}

	return result
}

func invertInterval(intervals []Interval, l, r int64) []Interval {
	outside := make([]Interval, 0)
	for _, iv := range intervals {
		if iv.r < l || iv.l > r {
			outside = append(outside, iv)
		} else {
			if iv.l < l {
				outside = append(outside, Interval{iv.l, l - 1})
			}
			if iv.r > r {
				outside = append(outside, Interval{r + 1, iv.r})
			}
		}
	}

	gaps := make([]Interval, 0)
	current := l

	for _, iv := range intervals {
		if iv.r < l {
			continue
		}
		if iv.l > r {
			break
		}

		ivStart := max(iv.l, l)
		ivEnd := min(iv.r, r)

		if current < ivStart {
			gaps = append(gaps, Interval{current, ivStart - 1})
		}
		current = max(current, ivEnd+1)
	}

	if current <= r {
		gaps = append(gaps, Interval{current, r})
	}

	return mergeIntervals(outside, gaps)
}

func mergeIntervals(a, b []Interval) []Interval {
	result := make([]Interval, 0)
	i, j := 0, 0

	for i < len(a) || j < len(b) {
		var iv Interval
		if j == len(b) || (i < len(a) && a[i].l <= b[j].l) {
			iv = a[i]
			i++
		} else {
			iv = b[j]
			j++
		}

		if len(result) == 0 || result[len(result)-1].r < iv.l-1 {
			result = append(result, iv)
		} else {
			result[len(result)-1].r = max(result[len(result)-1].r, iv.r)
		}
	}

	return result
}

func findMEX(intervals []Interval) int64 {
	mex := int64(1)

	for _, iv := range intervals {
		if iv.l > mex {
			return mex
		}
		if iv.r >= mex {
			mex = iv.r + 1
		}
	}

	return mex
}

func min(a, b int64) int64 {
	if a < b {
		return a
	}
	return b
}

func max(a, b int64) int64 {
	if a > b {
		return a
	}
	return b
}
```