class SegmentTree:
    def __init__(self):
        self.max_T = 10000  # Maximum possible T
        self.size = self.max_T + 1  # 0 to 10000 inclusive
        self.n = 1
        while self.n < self.size:
            self.n <<= 1
        # Initialize tree with negative infinity
        self.tree = [-float('inf')] * (2 * self.n)

    def update(self, T, R):
        # Updates the value at position T to be the max between existing and R
        pos = T + self.n
        if self.tree[pos] >= R:
            return
        self.tree[pos] = R
        pos >>= 1
        while pos >= 1:
            new_val = max(self.tree[2 * pos], self.tree[2 * pos + 1])
            if self.tree[pos] == new_val:
                break
            self.tree[pos] = new_val
            pos >>= 1

    def query(self, L):
        # Returns the maximum R in [L, max_T]
        res = -float('inf')
        a = L
        b = self.max_T
        a += self.n
        b += self.n
        while a <= b:
            if a % 2 == 1:
                res = max(res, self.tree[a])
                a += 1
            if b % 2 == 0:
                res = max(res, self.tree[b])
                b -= 1
            a >>= 1
            b >>= 1
        return res

def main():
    import sys
    input = sys.stdin.read().split()
    ptr = 0
    N = int(input[ptr])
    ptr +=1
    points = []
    for i in range(N):
        P = int(input[ptr])
        T = int(input[ptr+1])
        R = int(input[ptr+2])
        ptr +=3
        points.append( ( -P, -T, -R, i+1 ) )
    
    # Sort by descending P, then T, then R
    points.sort()
    seg = SegmentTree()
    ans = []
    for p in points:
        P_neg, T_neg, R_neg, idx = p
        T_real = -T_neg
        R_real = -R_neg
        # Query from T_real to max_T
        max_r = seg.query(T_real)
        if max_r >= R_real:
            continue
        ans.append(idx)
        seg.update(T_real, R_real)
    ans.sort()
    print('\n'.join(map(str, ans)))

if __name__ == "__main__":
    main()