Problem:
Problem G: Double or Increment

Problem

ある日、mo3tthi君とtubuann君は、魔法のポケットとビスケットを使ってゲームをすることにしました。

今ここに $K$ 個のポケットがあり、$1,2, \ldots ,K$ の番号がついています。

$i$ 番目のポケットの容量は $M_i$ で、最初 $N_i$ 枚のビスケットが入っています。

mo3tthi君とtubuann君は、mo3tthi君から始めて、以下の一連の操作を交互に行います。

ポケットを一つ選ぶ。

以下のいずれか一方の操作を一度だけ行う。ただし、操作の結果選んだポケットに入っているビスケットの枚数がポケットの容量を超える場合、操作を行うことはできない。

選んだポケットを撫でる。魔法の力によって選んだポケットに入っているビスケットの枚数が $1$ 増える。

選んだポケットを叩く。魔法の力によって選んだポケットに入っているビスケットの枚数が $2$ 倍になる。

操作を行えなくなった時点でゲームは終了し、操作を行えなくなった人が負け、そうでない人が勝ちになります。

mo3tthi君の友人であるあなたは、mo3tthi君から事前にこのゲームに勝てるかどうかを判定できないか相談されました。

mo3tthi君のために、mo3tthi君がこのゲームに必ず勝つことができるかどうかを判定するプログラムを作ってください。

Input

入力は以下の形式で与えられる。

$K$
$N_1$ $M_1$
$\vdots$
$N_K$ $M_K$

Constraints

入力は以下の条件を満たす。

$1 \leq K \leq 10^5$

$1 \leq N_i \leq M_i \leq 10^{18}$

入力は全て整数である

Output

mo3tthi君が最適に行動したとき、必ず勝つことができるなら"mo3tthi"を、そうでないなら"tubuann"を一行に出力する。

Sample Input 1

1
2 4

Sample Output 1

mo3tthi

mo3tthi君が一番目のポケットを叩くと、一番目のポケットに入っているビスケットの枚数が $4$ になり、tubuann君は操作を行うことができない。

Sample Input 2

2
2 3
3 8

Sample Output 2

tubuann

Sample Input 3

10
2 8
5 9
7 20
8 41
23 48
90 112
4 5
7 7
2344 8923
1 29

Sample Output 3

mo3tthi

Solution in Rust (judge verdict: Accepted)

//https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

macro_rules! input_inner {
    ($iter:expr) => {};
    ($iter:expr, ) => {};
    ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($iter, $t);
        input_inner!{$iter $($r)*}
    };
}

macro_rules! read_value {
    ($iter:expr, ( $($t:tt),* )) => {
        ( $(read_value!($iter, $t)),* )
    };
    ($iter:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()
    };
    ($iter:expr, chars) => {
        read_value!($iter, String).chars().collect::<Vec<char>>()
    };
    ($iter:expr, usize1) => {
        read_value!($iter, usize) - 1
    };
    ($iter:expr, $t:ty) => {
        $iter.next().unwrap().parse::<$t>().expect("Parse error")
    };
}

//

fn run() {
    input! {
        n: usize,
        p: [(usize, usize); n],
    }
    let mut g = 0;
    for (a, b) in p {
        let mut l = b / 2;
        let mut r = b;
        let mut dp = [0, 1];
        while l >= a {
            let (ll, rr) = (l / 2, l);
            let mut u = [false; 3];
            u[dp[(r - 2 * rr) % 2]] = true;
            u[dp[(r - (rr + 1)) % 2]] = true;
            let x = u.iter().position(|p| !*p).unwrap();
            let mut u = [false; 3];
            u[x] = true;
            u[dp[(r - 2 * (rr - 1)) % 2]] = true;
            let y = u.iter().position(|p| !*p).unwrap();
            dp = [x, y];
            l = ll;
            r = rr;
        }
        g ^= dp[(r - a) % 2];
    }
    let ans = if g > 0 {"mo3tthi"} else {"tubuann"};
    println!("{}", ans);
}

fn main() {
    run();
}