from sys import stdin
input = stdin.readline
n = int(input())
T = 2001
t, d, p, idx = [], [], [], []
ans = []
arr = []
for i in range(n):
    a, b, c = map(int, input().split())
    arr.append([a, b, c, i])
arr.sort(key=lambda x: x[1])
for i in arr:
    t.append(i[0]); d.append(i[1]); p.append(i[2]); idx.append(i[3])
dp = [[0 for j in range(n)] for i in range(T)]
for time in range(1, T):
    for i in range(n):
        #dp[time][i] = max(dp[time - 1][i], dp[time][i - 1])
        dp[time][i] = dp[time][i - 1]
        if d[i] > time >= t[i]:
            if i:
                dp[time][i] = max(dp[time][i], p[i] + dp[time - t[i]][i - 1])
            else:
                dp[time][i] = p[i]
b = [0, 0]
for i in range(T):
    for j in range(n):
        if b[0] < dp[i][j]:
            b = [dp[i][j], [i, j]]
print(b[0])
b = b[1]
while dp[b[0]][b[1]] and b[0] > -1:
    if b[1] and dp[b[0]][b[1]] != dp[b[0]][b[1] - 1]:
        ans.append(b[1])
        b[0] -= t[b[1]]
    elif b[1] == 0:
        if dp[b[0]][b[1]]:
            ans.append(b[1])
        break
    b[1] -= 1
print(len(ans))
for i in ans[::-1]:
    print(idx[i] + 1, end=' ')


from sys import stdin

n = int(stdin.readline())

items = []

for i in range(n):
  t,d,p = [int(x) for x in stdin.readline().split()]
  items.append((d,t,p,i))

items.sort()

mem = [{} for x in range(n)]
mem2 = [{} for x in range(n)]

def best(time,x):
  if time in mem[x]:
    return mem[x][time]

  time += items[x][1]

  if time+items[x][1] >= items[x][0]:
    mem[x][time] = 0
    mem2[x][time] = -1
    return 0

  top = 0
  top2 = -1

  for i in range(x+1,n):
    temp = best(time,i)
    if temp > top:
      top = temp
      top2 = i

  mem[x][time] = top+items[x][2]
  mem2[x][time] = top2
  return mem[x][time]

top = -1
l = []

for x in range(n):
  b = best(0,x)
  if b > top:
    top = b
    #print('new',x,top)
    l = []
    c = x
    time = 0
    while c != -1:
      l.append(items[c][3])
      time += items[c][1]
      if time in mem2[c]:
        c = mem2[c][time]
      else:
        c = -1

print(top)
print(len(l))
print(' '.join([str(x+1) for x in l]))


from sys import stdin

n = int(stdin.readline())

items = []

for i in range(n):
  t,d,p = [int(x) for x in stdin.readline().split()]
  items.append((d,t,p,i))

items.sort()

mem = [{} for x in range(n)]
mem2 = [{} for x in range(n)]

def best(time,x):
  if time in mem[x]:
    return mem[x][time]

  if time+items[x][1] >= items[x][0]:
    mem[x][time] = 0
    mem2[x][time+items[x][1]] = -1
    return 0

  top = 0
  top2 = -1
  time += items[x][1]

  for i in range(x+1,n):
    temp = best(time,i)
    if temp > top:
      top = temp
      top2 = i

  mem[x][time] = top+items[x][2]
  mem2[x][time] = top2
  return mem[x][time]

top = -1
l = []

for x in range(n):
  b = best(0,x)
  if b > top:
    top = b
    #print('new',x,top)
    l = []
    c = x
    time = 0
    while c != -1:
      l.append(items[c][3])
      time += items[c][1]
      if time in mem2[c]:
        c = mem2[c][time]
      else:
        c = -1

print(top)
print(len(l))
print(' '.join([str(x+1) for x in l]))


from sys import stdin

n = int(stdin.readline())

items = []

for i in range(n):
  t,d,p = [int(x) for x in stdin.readline().split()]
  items.append((d,t,p,i))

items.sort()

mem = [{} for x in range(n)]
mem2 = [{} for x in range(n)]

def best(time,x):
  if time in mem[x]:
    return mem[x][time]

  if time+items[x][1] >= items[x][0]:
    mem[x][time] = 0
    mem2[x][time+items[x][1]] = -1
    return 0

  top = 0
  top2 = -1
  time += items[x][1]

  for i in range(x+1,n):
    temp = best(time,i)
    if temp > top:
      top = temp
      top2 = i

  mem[x][time] = top+items[x][2]
  mem2[x][time] = top2
  return mem[x][time]

top = -1
l = []

for x in range(n):
  b = best(0,x)
  if b > top:
    top = b
    #print('new',x,top)
    l = []
    c = x
    time = 0
    while c != -1:
      l.append(items[c][3])
      time += items[c][1]
      c = mem2[c][time]

print(top)
print(len(l))
print(' '.join([str(x+1) for x in l]))


from sys import stdin

n = int(stdin.readline())

items = []

for i in range(n):
  t,d,p = [int(x) for x in stdin.readline().split()]
  items.append((d,t,p,i))

items.sort()

mem = [{} for x in range(n)]
mem2 = [{} for x in range(n)]

def best(time,x):
  time += items[x][1]
  if time in mem[x]:
    return mem[x][time]

  if time >= items[x][0]:
    mem[x][time] = 0
    mem2[x][time] = -1
    return 0

  top = 0
  top2 = -1

  for i in range(x+1,n):
    temp = best(time,i)
    if temp > top:
      top = temp
      top2 = i

  mem[x][time] = top+items[x][2]
  mem2[x][time] = top2
  return mem[x][time]

top = -1
l = []

for x in range(n):
  b = best(0,x)
  if b > top:
    top = b
    #print('new',x,top)
    l = []
    c = x
    time = 0
    while c != -1:
      time += items[c][1]
      l.append(items[c][3])
      if time in mem2[c]:
        c = mem2[c][time]
      else:
        c = -1

print(top)
print(len(l))
print(' '.join([str(x+1) for x in l]))


from sys import stdin

n = int(stdin.readline())

items = []

for i in range(n):
  t,d,p = [int(x) for x in stdin.readline().split()]
  items.append((d,t,p,i))

items.sort()

mem = [{} for x in range(n)]
mem2 = [{} for x in range(n)]

def best(time,x):
  if time in mem[x]:
    return mem[x][time]

  time += items[x][1]

  if time >= items[x][0]:
    mem[x][time] = 0
    mem2[x][time] = -1
    return 0

  top = 0
  top2 = -1

  for i in range(x+1,n):
    temp = best(time,i)
    if temp > top:
      top = temp
      top2 = i

  mem[x][time] = top+items[x][2]
  mem2[x][time] = top2
  return mem[x][time]

top = -1
l = []

for x in range(n):
  b = best(0,x)
  if b > top:
    top = b
    #print('new',x,top)
    l = []
    c = x
    time = 0
    while c != -1:
      l.append(items[c][3])
      time += items[c][1]
      if time in mem2[c]:
        c = mem2[c][time]
      else:
        c = -1

print(top)
print(len(l))
print(' '.join([str(x+1) for x in l]))


from sys import stdin

n = int(stdin.readline())

items = []

for i in range(n):
  t,d,p = [int(x) for x in stdin.readline().split()]
  items.append((d,t,p,i))

items.sort()

mem = [{} for x in range(n)]
mem2 = [{} for x in range(n)]

def best(time,x):
  time += items[x][1]
  if time in mem[x]:
    return mem[x][time]

  if time >= items[x][0]:
    mem[x][time] = 0
    mem2[x][time] = -1
    return 0

  top = 0
  top2 = -1

  for i in range(x+1,n):
    temp = best(time,i)
    if temp > top:
      top = temp
      top2 = i

  mem[x][time] = top+items[x][2]
  mem2[x][time] = top2
  return mem[x][time]

top = -1
l = []

for x in range(n):
  b = best(0,x)
  if b > top:
    top = b
    #print('new',x,top)
    l = []
    c = x
    time = 0
    while c != -1:
      time += items[c][1]
      l.append(items[c][3])
      if time in mem2[c]:
        c = mem2[c][time]
      else:
        c = -1

print(top)
if top != 0:
  print(len(l))
  print(' '.join([str(x+1) for x in l]))
else:
  print(0)
  print(0)


from sys import stdin

n = int(stdin.readline())

items = []

for i in range(n):
  t,d,p = [int(x) for x in stdin.readline().split()]
  items.append((d,t,p,i))

items.sort()

mem = [{} for x in range(n)]
mem2 = [{} for x in range(n)]

def best(time,x):
  time += items[x][1]
  if time in mem[x]:
    return mem[x][time]

  if time >= items[x][0]:
    mem[x][time] = 0
    mem2[x][time] = -1
    return 0

  top = 0
  top2 = -1

  for i in range(x+1,n):
    temp = best(time,i)
    if temp > top:
      top = temp
      top2 = i

  mem[x][time] = top+items[x][2]
  mem2[x][time] = top2
  return mem[x][time]

top = -1
l = []

for x in range(n):
  b = best(0,x)
  if b > top:
    top = b
    #print('new',x,top)
    l = []
    c = x
    time = 0
    while c != -1:
      time += items[c][1]
      l.append(items[c][3])
      if time in mem2[c]:
        c = mem2[c][time]
      else:
        c = -1

print(top)
if top != 0:
  print(len(l))
  print(' '.join([str(x+1) for x in l]))
else:
  print(0)
  print()


# ---------------------------iye ha aam zindegi---------------------------------------------
import math
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
import sys
mod = 10 ** 9 + 7
mod1 = 998244353
#setrecursionlimit(300000)
# ------------------------------warmup----------------------------
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
sys.setrecursionlimit(300000)
class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")

sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

# -------------------game starts now----------------------------------------------------import math
class TreeNode:
    def __init__(self, k, v):
        self.key = k
        self.value = v
        self.left = None
        self.right = None
        self.parent = None
        self.height = 1
        self.num_left = 1
        self.num_total = 1

class AvlTree:

    def __init__(self):
        self._tree = None

    def add(self, k, v):
        if not self._tree:
            self._tree = TreeNode(k, v)
            return
        node = self._add(k, v)
        if node:
            self._rebalance(node)

    def _add(self, k, v):
        node = self._tree
        while node:
            if k < node.key:
                if node.left:
                    node = node.left
                else:
                    node.left = TreeNode(k, v)
                    node.left.parent = node
                    return node.left
            elif node.key < k:
                if node.right:
                    node = node.right
                else:
                    node.right = TreeNode(k, v)
                    node.right.parent = node
                    return node.right
            else:
                node.value = v
                return

    @staticmethod
    def get_height(x):
        return x.height if x else 0

    @staticmethod
    def get_num_total(x):
        return x.num_total if x else 0

    def _rebalance(self, node):

        n = node
        while n:
            lh = self.get_height(n.left)
            rh = self.get_height(n.right)
            n.height = max(lh, rh) + 1
            balance_factor = lh - rh
            n.num_total = 1 + self.get_num_total(n.left) + self.get_num_total(n.right)
            n.num_left = 1 + self.get_num_total(n.left)

            if balance_factor > 1:
                if self.get_height(n.left.left) < self.get_height(n.left.right):
                    self._rotate_left(n.left)
                self._rotate_right(n)
            elif balance_factor < -1:
                if self.get_height(n.right.right) < self.get_height(n.right.left):
                    self._rotate_right(n.right)
                self._rotate_left(n)
            else:
                n = n.parent

    def _remove_one(self, node):
        """
        Side effect!!! Changes node. Node should have exactly one child
        """
        replacement = node.left or node.right
        if node.parent:
            if AvlTree._is_left(node):
                node.parent.left = replacement
            else:
                node.parent.right = replacement
            replacement.parent = node.parent
            node.parent = None
        else:
            self._tree = replacement
            replacement.parent = None
        node.left = None
        node.right = None
        node.parent = None
        self._rebalance(replacement)

    def _remove_leaf(self, node):
        if node.parent:
            if AvlTree._is_left(node):
                node.parent.left = None
            else:
                node.parent.right = None
            self._rebalance(node.parent)
        else:
            self._tree = None
        node.parent = None
        node.left = None
        node.right = None

    def remove(self, k):
        node = self._get_node(k)
        if not node:
            return
        if AvlTree._is_leaf(node):
            self._remove_leaf(node)
            return
        if node.left and node.right:
            nxt = AvlTree._get_next(node)
            node.key = nxt.key
            node.value = nxt.value
            if self._is_leaf(nxt):
                self._remove_leaf(nxt)
            else:
                self._remove_one(nxt)
            self._rebalance(node)
        else:
            self._remove_one(node)

    def get(self, k):
        node = self._get_node(k)
        return node.value if node else -1

    def _get_node(self, k):
        if not self._tree:
            return None
        node = self._tree
        while node:
            if k < node.key:
                node = node.left
            elif node.key < k:
                node = node.right
            else:
                return node
        return None

    def get_at(self, pos):
        x = pos + 1
        node = self._tree
        while node:
            if x < node.num_left:
                node = node.left
            elif node.num_left < x:
                x -= node.num_left
                node = node.right
            else:
                return (node.key, node.value)
        raise IndexError("Out of ranges")

    @staticmethod
    def _is_left(node):
        return node.parent.left and node.parent.left == node

    @staticmethod
    def _is_leaf(node):
        return node.left is None and node.right is None

    def _rotate_right(self, node):
        if not node.parent:
            self._tree = node.left
            node.left.parent = None
        elif AvlTree._is_left(node):
            node.parent.left = node.left
            node.left.parent = node.parent
        else:
            node.parent.right = node.left
            node.left.parent = node.parent
        bk = node.left.right
        node.left.right = node
        node.parent = node.left
        node.left = bk
        if bk:
            bk.parent = node
        node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
        node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
        node.num_left = 1 + self.get_num_total(node.left)

    def _rotate_left(self, node):
        if not node.parent:
            self._tree = node.right
            node.right.parent = None
        elif AvlTree._is_left(node):
            node.parent.left = node.right
            node.right.parent = node.parent
        else:
            node.parent.right = node.right
            node.right.parent = node.parent
        bk = node.right.left
        node.right.left = node
        node.parent = node.right
        node.right = bk
        if bk:
            bk.parent = node
        node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
        node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
        node.num_left = 1 + self.get_num_total(node.left)

    @staticmethod
    def _get_next(node):
        if not node.right:
            return node.parent
        n = node.right
        while n.left:
            n = n.left
        return n

# -----------------------------------------------binary seacrh tree---------------------------------------
class SegmentTree1:
    def __init__(self, data, default=0, func=lambda a, b: max(a, b)):
        """initialize the segment tree with data"""
        self._default = default
        self._func = func
        self._len = len(data)
        self._size = _size = 1 << (self._len - 1).bit_length()

        self.data = [default] * (2 * _size)
        self.data[_size:_size + self._len] = data
        for i in reversed(range(_size)):
            self.data[i] = func(self.data[i + i], self.data[i + i + 1])

    def __delitem__(self, idx):
        self[idx] = self._default

    def __getitem__(self, idx):
        return self.data[idx + self._size]

    def __setitem__(self, idx, value):
        idx += self._size
        self.data[idx] = value
        idx >>= 1
        while idx:
            self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
            idx >>= 1

    def __len__(self):
        return self._len

    def query(self, start, stop):
        if start == stop:
            return self.__getitem__(start)
        stop += 1
        start += self._size
        stop += self._size

        res = self._default
        while start < stop:
            if start & 1:
                res = self._func(res, self.data[start])
                start += 1
            if stop & 1:
                stop -= 1
                res = self._func(res, self.data[stop])
            start >>= 1
            stop >>= 1
        return res

    def __repr__(self):
        return "SegmentTree({0})".format(self.data)

# -------------------game starts now----------------------------------------------------import math
class SegmentTree:
    def __init__(self, data, default=0, func=lambda a, b: a + b):
        """initialize the segment tree with data"""
        self._default = default
        self._func = func
        self._len = len(data)
        self._size = _size = 1 << (self._len - 1).bit_length()

        self.data = [default] * (2 * _size)
        self.data[_size:_size + self._len] = data
        for i in reversed(range(_size)):
            self.data[i] = func(self.data[i + i], self.data[i + i + 1])

    def __delitem__(self, idx):
        self[idx] = self._default

    def __getitem__(self, idx):
        return self.data[idx + self._size]

    def __setitem__(self, idx, value):
        idx += self._size
        self.data[idx] = value
        idx >>= 1
        while idx:
            self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
            idx >>= 1

    def __len__(self):
        return self._len

    def query(self, start, stop):
        if start == stop:
            return self.__getitem__(start)
        stop += 1
        start += self._size
        stop += self._size

        res = self._default
        while start < stop:
            if start & 1:
                res = self._func(res, self.data[start])
                start += 1
            if stop & 1:
                stop -= 1
                res = self._func(res, self.data[stop])
            start >>= 1
            stop >>= 1
        return res

    def __repr__(self):
        return "SegmentTree({0})".format(self.data)

# -------------------------------iye ha chutiya zindegi-------------------------------------
class Factorial:
    def __init__(self, MOD):
        self.MOD = MOD
        self.factorials = [1, 1]
        self.invModulos = [0, 1]
        self.invFactorial_ = [1, 1]

    def calc(self, n):
        if n <= -1:
            print("Invalid argument to calculate n!")
            print("n must be non-negative value. But the argument was " + str(n))
            exit()
        if n < len(self.factorials):
            return self.factorials[n]
        nextArr = [0] * (n + 1 - len(self.factorials))
        initialI = len(self.factorials)
        prev = self.factorials[-1]
        m = self.MOD
        for i in range(initialI, n + 1):
            prev = nextArr[i - initialI] = prev * i % m
        self.factorials += nextArr
        return self.factorials[n]

    def inv(self, n):
        if n <= -1:
            print("Invalid argument to calculate n^(-1)")
            print("n must be non-negative value. But the argument was " + str(n))
            exit()
        p = self.MOD
        pi = n % p
        if pi < len(self.invModulos):
            return self.invModulos[pi]
        nextArr = [0] * (n + 1 - len(self.invModulos))
        initialI = len(self.invModulos)
        for i in range(initialI, min(p, n + 1)):
            next = -self.invModulos[p % i] * (p // i) % p
            self.invModulos.append(next)
        return self.invModulos[pi]

    def invFactorial(self, n):
        if n <= -1:
            print("Invalid argument to calculate (n^(-1))!")
            print("n must be non-negative value. But the argument was " + str(n))
            exit()
        if n < len(self.invFactorial_):
            return self.invFactorial_[n]
        self.inv(n)  # To make sure already calculated n^-1
        nextArr = [0] * (n + 1 - len(self.invFactorial_))
        initialI = len(self.invFactorial_)
        prev = self.invFactorial_[-1]
        p = self.MOD
        for i in range(initialI, n + 1):
            prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
        self.invFactorial_ += nextArr
        return self.invFactorial_[n]

class Combination:
    def __init__(self, MOD):
        self.MOD = MOD
        self.factorial = Factorial(MOD)

    def ncr(self, n, k):
        if k < 0 or n < k:
            return 0
        k = min(k, n - k)
        f = self.factorial
        return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD

# --------------------------------------iye ha combinations ka zindegi---------------------------------
def powm(a, n, m):
    if a == 1 or n == 0:
        return 1
    if n % 2 == 0:
        s = powm(a, n // 2, m)
        return s * s % m
    else:
        return a * powm(a, n - 1, m) % m

# --------------------------------------iye ha power ka zindegi---------------------------------
def sort_list(list1, list2):
    zipped_pairs = zip(list2, list1)

    z = [x for _, x in sorted(zipped_pairs)]

    return z

# --------------------------------------------------product----------------------------------------
def product(l):
    por = 1
    for i in range(len(l)):
        por *= l[i]
    return por

# --------------------------------------------------binary----------------------------------------
def binarySearchCount(arr, n, key):
    left = 0
    right = n - 1

    count = 0

    while (left <= right):
        mid = int((right + left) / 2)

        # Check if middle element is
        # less than or equal to key
        if (arr[mid] < key):
            count = mid + 1
            left = mid + 1

        # If key is smaller, ignore right half
        else:
            right = mid - 1

    return count

# --------------------------------------------------binary----------------------------------------
def countdig(n):
    c = 0
    while (n > 0):
        n //= 10
        c += 1
    return c
def binary(x, length):
    y = bin(x)[2:]
    return y if len(y) >= length else "0" * (length - len(y)) + y

def countGreater(arr, n, k):
    l = 0
    r = n - 1

    # Stores the index of the left most element
    # from the array which is greater than k
    leftGreater = n

    # Finds number of elements greater than k
    while (l <= r):
        m = int(l + (r - l) / 2)
        if (arr[m] >= k):
            leftGreater = m
            r = m - 1

        # If mid element is less than
        # or equal to k update l
        else:
            l = m + 1

    # Return the count of elements
    # greater than k
    return (n - leftGreater)

# --------------------------------------------------binary------------------------------------
n=int(input())
ma=0
l=[]
time=[]
for i in range(n):
    s=list(map(int,input().split()))
    ma=max(ma,s[1])
    l.append(s+[i+1])
    time.append(s[1])
l=sort_list(l,time)
dp=[[[] for i in range(ma+1)]for j in range(n)]
dp1=[[0 for i in range(ma+1)]for j in range(n)]
for i in range(ma+1):
    if l[0][0]<i<=l[0][1]:
        dp1[0][i]=l[0][2]
        dp[0][i]=[l[0][-1]]
for i in range(1,n):
    for j in range(ma+1):
        if j-l[i][0]>0 and j<=l[i][1]:
            dp1[i][j]=max(dp1[i-1][j],dp1[i-1][j-l[i][0]]+l[i][2])
            if dp1[i][j]==dp1[i-1][j]:
                dp[i][j]=dp[i-1][j]+[]
            else:
                dp[i][j]=dp[i-1][j-l[i][0]]+[l[i][-1]]
        else:
            dp1[i][j]=dp1[i-1][j]
            dp[i][j]=dp[i-1][j]+[]
ans=max(dp1[-1])
print(ans)
ind=dp1[-1].index(ans)
print(len(dp[-1][ind]))
print(*dp[-1][ind])


# ---------------------------iye ha aam zindegi---------------------------------------------
import math
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
import sys
mod = 10 ** 9 + 7
mod1 = 998244353
#setrecursionlimit(300000)
# ------------------------------warmup----------------------------
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
sys.setrecursionlimit(300000)
class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")

sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

# -------------------game starts now----------------------------------------------------import math
class TreeNode:
    def __init__(self, k, v):
        self.key = k
        self.value = v
        self.left = None
        self.right = None
        self.parent = None
        self.height = 1
        self.num_left = 1
        self.num_total = 1

class AvlTree:

    def __init__(self):
        self._tree = None

    def add(self, k, v):
        if not self._tree:
            self._tree = TreeNode(k, v)
            return
        node = self._add(k, v)
        if node:
            self._rebalance(node)

    def _add(self, k, v):
        node = self._tree
        while node:
            if k < node.key:
                if node.left:
                    node = node.left
                else:
                    node.left = TreeNode(k, v)
                    node.left.parent = node
                    return node.left
            elif node.key < k:
                if node.right:
                    node = node.right
                else:
                    node.right = TreeNode(k, v)
                    node.right.parent = node
                    return node.right
            else:
                node.value = v
                return

    @staticmethod
    def get_height(x):
        return x.height if x else 0

    @staticmethod
    def get_num_total(x):
        return x.num_total if x else 0

    def _rebalance(self, node):

        n = node
        while n:
            lh = self.get_height(n.left)
            rh = self.get_height(n.right)
            n.height = max(lh, rh) + 1
            balance_factor = lh - rh
            n.num_total = 1 + self.get_num_total(n.left) + self.get_num_total(n.right)
            n.num_left = 1 + self.get_num_total(n.left)

            if balance_factor > 1:
                if self.get_height(n.left.left) < self.get_height(n.left.right):
                    self._rotate_left(n.left)
                self._rotate_right(n)
            elif balance_factor < -1:
                if self.get_height(n.right.right) < self.get_height(n.right.left):
                    self._rotate_right(n.right)
                self._rotate_left(n)
            else:
                n = n.parent

    def _remove_one(self, node):
        """
        Side effect!!! Changes node. Node should have exactly one child
        """
        replacement = node.left or node.right
        if node.parent:
            if AvlTree._is_left(node):
                node.parent.left = replacement
            else:
                node.parent.right = replacement
            replacement.parent = node.parent
            node.parent = None
        else:
            self._tree = replacement
            replacement.parent = None
        node.left = None
        node.right = None
        node.parent = None
        self._rebalance(replacement)

    def _remove_leaf(self, node):
        if node.parent:
            if AvlTree._is_left(node):
                node.parent.left = None
            else:
                node.parent.right = None
            self._rebalance(node.parent)
        else:
            self._tree = None
        node.parent = None
        node.left = None
        node.right = None

    def remove(self, k):
        node = self._get_node(k)
        if not node:
            return
        if AvlTree._is_leaf(node):
            self._remove_leaf(node)
            return
        if node.left and node.right:
            nxt = AvlTree._get_next(node)
            node.key = nxt.key
            node.value = nxt.value
            if self._is_leaf(nxt):
                self._remove_leaf(nxt)
            else:
                self._remove_one(nxt)
            self._rebalance(node)
        else:
            self._remove_one(node)

    def get(self, k):
        node = self._get_node(k)
        return node.value if node else -1

    def _get_node(self, k):
        if not self._tree:
            return None
        node = self._tree
        while node:
            if k < node.key:
                node = node.left
            elif node.key < k:
                node = node.right
            else:
                return node
        return None

    def get_at(self, pos):
        x = pos + 1
        node = self._tree
        while node:
            if x < node.num_left:
                node = node.left
            elif node.num_left < x:
                x -= node.num_left
                node = node.right
            else:
                return (node.key, node.value)
        raise IndexError("Out of ranges")

    @staticmethod
    def _is_left(node):
        return node.parent.left and node.parent.left == node

    @staticmethod
    def _is_leaf(node):
        return node.left is None and node.right is None

    def _rotate_right(self, node):
        if not node.parent:
            self._tree = node.left
            node.left.parent = None
        elif AvlTree._is_left(node):
            node.parent.left = node.left
            node.left.parent = node.parent
        else:
            node.parent.right = node.left
            node.left.parent = node.parent
        bk = node.left.right
        node.left.right = node
        node.parent = node.left
        node.left = bk
        if bk:
            bk.parent = node
        node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
        node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
        node.num_left = 1 + self.get_num_total(node.left)

    def _rotate_left(self, node):
        if not node.parent:
            self._tree = node.right
            node.right.parent = None
        elif AvlTree._is_left(node):
            node.parent.left = node.right
            node.right.parent = node.parent
        else:
            node.parent.right = node.right
            node.right.parent = node.parent
        bk = node.right.left
        node.right.left = node
        node.parent = node.right
        node.right = bk
        if bk:
            bk.parent = node
        node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
        node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
        node.num_left = 1 + self.get_num_total(node.left)

    @staticmethod
    def _get_next(node):
        if not node.right:
            return node.parent
        n = node.right
        while n.left:
            n = n.left
        return n

# -----------------------------------------------binary seacrh tree---------------------------------------
class SegmentTree1:
    def __init__(self, data, default=0, func=lambda a, b: max(a, b)):
        """initialize the segment tree with data"""
        self._default = default
        self._func = func
        self._len = len(data)
        self._size = _size = 1 << (self._len - 1).bit_length()

        self.data = [default] * (2 * _size)
        self.data[_size:_size + self._len] = data
        for i in reversed(range(_size)):
            self.data[i] = func(self.data[i + i], self.data[i + i + 1])

    def __delitem__(self, idx):
        self[idx] = self._default

    def __getitem__(self, idx):
        return self.data[idx + self._size]

    def __setitem__(self, idx, value):
        idx += self._size
        self.data[idx] = value
        idx >>= 1
        while idx:
            self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
            idx >>= 1

    def __len__(self):
        return self._len

    def query(self, start, stop):
        if start == stop:
            return self.__getitem__(start)
        stop += 1
        start += self._size
        stop += self._size

        res = self._default
        while start < stop:
            if start & 1:
                res = self._func(res, self.data[start])
                start += 1
            if stop & 1:
                stop -= 1
                res = self._func(res, self.data[stop])
            start >>= 1
            stop >>= 1
        return res

    def __repr__(self):
        return "SegmentTree({0})".format(self.data)

# -------------------game starts now----------------------------------------------------import math
class SegmentTree:
    def __init__(self, data, default=0, func=lambda a, b: a + b):
        """initialize the segment tree with data"""
        self._default = default
        self._func = func
        self._len = len(data)
        self._size = _size = 1 << (self._len - 1).bit_length()

        self.data = [default] * (2 * _size)
        self.data[_size:_size + self._len] = data
        for i in reversed(range(_size)):
            self.data[i] = func(self.data[i + i], self.data[i + i + 1])

    def __delitem__(self, idx):
        self[idx] = self._default

    def __getitem__(self, idx):
        return self.data[idx + self._size]

    def __setitem__(self, idx, value):
        idx += self._size
        self.data[idx] = value
        idx >>= 1
        while idx:
            self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
            idx >>= 1

    def __len__(self):
        return self._len

    def query(self, start, stop):
        if start == stop:
            return self.__getitem__(start)
        stop += 1
        start += self._size
        stop += self._size

        res = self._default
        while start < stop:
            if start & 1:
                res = self._func(res, self.data[start])
                start += 1
            if stop & 1:
                stop -= 1
                res = self._func(res, self.data[stop])
            start >>= 1
            stop >>= 1
        return res

    def __repr__(self):
        return "SegmentTree({0})".format(self.data)

# -------------------------------iye ha chutiya zindegi-------------------------------------
class Factorial:
    def __init__(self, MOD):
        self.MOD = MOD
        self.factorials = [1, 1]
        self.invModulos = [0, 1]
        self.invFactorial_ = [1, 1]

    def calc(self, n):
        if n <= -1:
            print("Invalid argument to calculate n!")
            print("n must be non-negative value. But the argument was " + str(n))
            exit()
        if n < len(self.factorials):
            return self.factorials[n]
        nextArr = [0] * (n + 1 - len(self.factorials))
        initialI = len(self.factorials)
        prev = self.factorials[-1]
        m = self.MOD
        for i in range(initialI, n + 1):
            prev = nextArr[i - initialI] = prev * i % m
        self.factorials += nextArr
        return self.factorials[n]

    def inv(self, n):
        if n <= -1:
            print("Invalid argument to calculate n^(-1)")
            print("n must be non-negative value. But the argument was " + str(n))
            exit()
        p = self.MOD
        pi = n % p
        if pi < len(self.invModulos):
            return self.invModulos[pi]
        nextArr = [0] * (n + 1 - len(self.invModulos))
        initialI = len(self.invModulos)
        for i in range(initialI, min(p, n + 1)):
            next = -self.invModulos[p % i] * (p // i) % p
            self.invModulos.append(next)
        return self.invModulos[pi]

    def invFactorial(self, n):
        if n <= -1:
            print("Invalid argument to calculate (n^(-1))!")
            print("n must be non-negative value. But the argument was " + str(n))
            exit()
        if n < len(self.invFactorial_):
            return self.invFactorial_[n]
        self.inv(n)  # To make sure already calculated n^-1
        nextArr = [0] * (n + 1 - len(self.invFactorial_))
        initialI = len(self.invFactorial_)
        prev = self.invFactorial_[-1]
        p = self.MOD
        for i in range(initialI, n + 1):
            prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
        self.invFactorial_ += nextArr
        return self.invFactorial_[n]

class Combination:
    def __init__(self, MOD):
        self.MOD = MOD
        self.factorial = Factorial(MOD)

    def ncr(self, n, k):
        if k < 0 or n < k:
            return 0
        k = min(k, n - k)
        f = self.factorial
        return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD

# --------------------------------------iye ha combinations ka zindegi---------------------------------
def powm(a, n, m):
    if a == 1 or n == 0:
        return 1
    if n % 2 == 0:
        s = powm(a, n // 2, m)
        return s * s % m
    else:
        return a * powm(a, n - 1, m) % m

# --------------------------------------iye ha power ka zindegi---------------------------------
def sort_list(list1, list2):
    zipped_pairs = zip(list2, list1)

    z = [x for _, x in sorted(zipped_pairs)]

    return z

# --------------------------------------------------product----------------------------------------
def product(l):
    por = 1
    for i in range(len(l)):
        por *= l[i]
    return por

# --------------------------------------------------binary----------------------------------------
def binarySearchCount(arr, n, key):
    left = 0
    right = n - 1

    count = 0

    while (left <= right):
        mid = int((right + left) / 2)

        # Check if middle element is
        # less than or equal to key
        if (arr[mid] < key):
            count = mid + 1
            left = mid + 1

        # If key is smaller, ignore right half
        else:
            right = mid - 1

    return count

# --------------------------------------------------binary----------------------------------------
def countdig(n):
    c = 0
    while (n > 0):
        n //= 10
        c += 1
    return c
def binary(x, length):
    y = bin(x)[2:]
    return y if len(y) >= length else "0" * (length - len(y)) + y

def countGreater(arr, n, k):
    l = 0
    r = n - 1

    # Stores the index of the left most element
    # from the array which is greater than k
    leftGreater = n

    # Finds number of elements greater than k
    while (l <= r):
        m = int(l + (r - l) / 2)
        if (arr[m] >= k):
            leftGreater = m
            r = m - 1

        # If mid element is less than
        # or equal to k update l
        else:
            l = m + 1

    # Return the count of elements
    # greater than k
    return (n - leftGreater)

# --------------------------------------------------binary------------------------------------
n=int(input())
ma=0
l=[]
time=[]
for i in range(n):
    s=list(map(int,input().split()))
    ma=max(ma,s[1])
    l.append(s+[i+1])
    time.append(s[1])
l=sort_list(l,time)
dp=[[[] for i in range(ma+1)]for j in range(n)]
dp1=[[0 for i in range(ma+1)]for j in range(n)]
for i in range(ma+1):
    if l[0][0]<i<=l[0][1]:
        dp1[0][i]=l[0][2]
        dp[0][i]=[l[0][-1]]
for i in range(1,n):
    for j in range(ma+1):
        if j-l[i][0]>0 and j<=l[i][1]:
            dp1[i][j]=dp1[i-1][j-l[i][0]-1]+l[i][2]
            dp[i][j]=dp[i-1][j-l[i][0]-1]+[l[i][-1]]
        else:
            dp1[i][j]=dp1[i-1][j]
            dp[i][j]=dp[i-1][j]
ans=max(dp1[-1])
print(ans)
ind=dp1[-1].index(ans)
print(len(dp[-1][ind]))
print(*dp[-1][ind])


# ---------------------------iye ha aam zindegi---------------------------------------------
import math
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
import sys
mod = 10 ** 9 + 7
mod1 = 998244353
#setrecursionlimit(300000)
# ------------------------------warmup----------------------------
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
sys.setrecursionlimit(300000)
class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")

sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

# -------------------game starts now----------------------------------------------------import math
class TreeNode:
    def __init__(self, k, v):
        self.key = k
        self.value = v
        self.left = None
        self.right = None
        self.parent = None
        self.height = 1
        self.num_left = 1
        self.num_total = 1

class AvlTree:

    def __init__(self):
        self._tree = None

    def add(self, k, v):
        if not self._tree:
            self._tree = TreeNode(k, v)
            return
        node = self._add(k, v)
        if node:
            self._rebalance(node)

    def _add(self, k, v):
        node = self._tree
        while node:
            if k < node.key:
                if node.left:
                    node = node.left
                else:
                    node.left = TreeNode(k, v)
                    node.left.parent = node
                    return node.left
            elif node.key < k:
                if node.right:
                    node = node.right
                else:
                    node.right = TreeNode(k, v)
                    node.right.parent = node
                    return node.right
            else:
                node.value = v
                return

    @staticmethod
    def get_height(x):
        return x.height if x else 0

    @staticmethod
    def get_num_total(x):
        return x.num_total if x else 0

    def _rebalance(self, node):

        n = node
        while n:
            lh = self.get_height(n.left)
            rh = self.get_height(n.right)
            n.height = max(lh, rh) + 1
            balance_factor = lh - rh
            n.num_total = 1 + self.get_num_total(n.left) + self.get_num_total(n.right)
            n.num_left = 1 + self.get_num_total(n.left)

            if balance_factor > 1:
                if self.get_height(n.left.left) < self.get_height(n.left.right):
                    self._rotate_left(n.left)
                self._rotate_right(n)
            elif balance_factor < -1:
                if self.get_height(n.right.right) < self.get_height(n.right.left):
                    self._rotate_right(n.right)
                self._rotate_left(n)
            else:
                n = n.parent

    def _remove_one(self, node):
        """
        Side effect!!! Changes node. Node should have exactly one child
        """
        replacement = node.left or node.right
        if node.parent:
            if AvlTree._is_left(node):
                node.parent.left = replacement
            else:
                node.parent.right = replacement
            replacement.parent = node.parent
            node.parent = None
        else:
            self._tree = replacement
            replacement.parent = None
        node.left = None
        node.right = None
        node.parent = None
        self._rebalance(replacement)

    def _remove_leaf(self, node):
        if node.parent:
            if AvlTree._is_left(node):
                node.parent.left = None
            else:
                node.parent.right = None
            self._rebalance(node.parent)
        else:
            self._tree = None
        node.parent = None
        node.left = None
        node.right = None

    def remove(self, k):
        node = self._get_node(k)
        if not node:
            return
        if AvlTree._is_leaf(node):
            self._remove_leaf(node)
            return
        if node.left and node.right:
            nxt = AvlTree._get_next(node)
            node.key = nxt.key
            node.value = nxt.value
            if self._is_leaf(nxt):
                self._remove_leaf(nxt)
            else:
                self._remove_one(nxt)
            self._rebalance(node)
        else:
            self._remove_one(node)

    def get(self, k):
        node = self._get_node(k)
        return node.value if node else -1

    def _get_node(self, k):
        if not self._tree:
            return None
        node = self._tree
        while node:
            if k < node.key:
                node = node.left
            elif node.key < k:
                node = node.right
            else:
                return node
        return None

    def get_at(self, pos):
        x = pos + 1
        node = self._tree
        while node:
            if x < node.num_left:
                node = node.left
            elif node.num_left < x:
                x -= node.num_left
                node = node.right
            else:
                return (node.key, node.value)
        raise IndexError("Out of ranges")

    @staticmethod
    def _is_left(node):
        return node.parent.left and node.parent.left == node

    @staticmethod
    def _is_leaf(node):
        return node.left is None and node.right is None

    def _rotate_right(self, node):
        if not node.parent:
            self._tree = node.left
            node.left.parent = None
        elif AvlTree._is_left(node):
            node.parent.left = node.left
            node.left.parent = node.parent
        else:
            node.parent.right = node.left
            node.left.parent = node.parent
        bk = node.left.right
        node.left.right = node
        node.parent = node.left
        node.left = bk
        if bk:
            bk.parent = node
        node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
        node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
        node.num_left = 1 + self.get_num_total(node.left)

    def _rotate_left(self, node):
        if not node.parent:
            self._tree = node.right
            node.right.parent = None
        elif AvlTree._is_left(node):
            node.parent.left = node.right
            node.right.parent = node.parent
        else:
            node.parent.right = node.right
            node.right.parent = node.parent
        bk = node.right.left
        node.right.left = node
        node.parent = node.right
        node.right = bk
        if bk:
            bk.parent = node
        node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
        node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
        node.num_left = 1 + self.get_num_total(node.left)

    @staticmethod
    def _get_next(node):
        if not node.right:
            return node.parent
        n = node.right
        while n.left:
            n = n.left
        return n

# -----------------------------------------------binary seacrh tree---------------------------------------
class SegmentTree1:
    def __init__(self, data, default=0, func=lambda a, b: max(a, b)):
        """initialize the segment tree with data"""
        self._default = default
        self._func = func
        self._len = len(data)
        self._size = _size = 1 << (self._len - 1).bit_length()

        self.data = [default] * (2 * _size)
        self.data[_size:_size + self._len] = data
        for i in reversed(range(_size)):
            self.data[i] = func(self.data[i + i], self.data[i + i + 1])

    def __delitem__(self, idx):
        self[idx] = self._default

    def __getitem__(self, idx):
        return self.data[idx + self._size]

    def __setitem__(self, idx, value):
        idx += self._size
        self.data[idx] = value
        idx >>= 1
        while idx:
            self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
            idx >>= 1

    def __len__(self):
        return self._len

    def query(self, start, stop):
        if start == stop:
            return self.__getitem__(start)
        stop += 1
        start += self._size
        stop += self._size

        res = self._default
        while start < stop:
            if start & 1:
                res = self._func(res, self.data[start])
                start += 1
            if stop & 1:
                stop -= 1
                res = self._func(res, self.data[stop])
            start >>= 1
            stop >>= 1
        return res

    def __repr__(self):
        return "SegmentTree({0})".format(self.data)

# -------------------game starts now----------------------------------------------------import math
class SegmentTree:
    def __init__(self, data, default=0, func=lambda a, b: a + b):
        """initialize the segment tree with data"""
        self._default = default
        self._func = func
        self._len = len(data)
        self._size = _size = 1 << (self._len - 1).bit_length()

        self.data = [default] * (2 * _size)
        self.data[_size:_size + self._len] = data
        for i in reversed(range(_size)):
            self.data[i] = func(self.data[i + i], self.data[i + i + 1])

    def __delitem__(self, idx):
        self[idx] = self._default

    def __getitem__(self, idx):
        return self.data[idx + self._size]

    def __setitem__(self, idx, value):
        idx += self._size
        self.data[idx] = value
        idx >>= 1
        while idx:
            self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
            idx >>= 1

    def __len__(self):
        return self._len

    def query(self, start, stop):
        if start == stop:
            return self.__getitem__(start)
        stop += 1
        start += self._size
        stop += self._size

        res = self._default
        while start < stop:
            if start & 1:
                res = self._func(res, self.data[start])
                start += 1
            if stop & 1:
                stop -= 1
                res = self._func(res, self.data[stop])
            start >>= 1
            stop >>= 1
        return res

    def __repr__(self):
        return "SegmentTree({0})".format(self.data)

# -------------------------------iye ha chutiya zindegi-------------------------------------
class Factorial:
    def __init__(self, MOD):
        self.MOD = MOD
        self.factorials = [1, 1]
        self.invModulos = [0, 1]
        self.invFactorial_ = [1, 1]

    def calc(self, n):
        if n <= -1:
            print("Invalid argument to calculate n!")
            print("n must be non-negative value. But the argument was " + str(n))
            exit()
        if n < len(self.factorials):
            return self.factorials[n]
        nextArr = [0] * (n + 1 - len(self.factorials))
        initialI = len(self.factorials)
        prev = self.factorials[-1]
        m = self.MOD
        for i in range(initialI, n + 1):
            prev = nextArr[i - initialI] = prev * i % m
        self.factorials += nextArr
        return self.factorials[n]

    def inv(self, n):
        if n <= -1:
            print("Invalid argument to calculate n^(-1)")
            print("n must be non-negative value. But the argument was " + str(n))
            exit()
        p = self.MOD
        pi = n % p
        if pi < len(self.invModulos):
            return self.invModulos[pi]
        nextArr = [0] * (n + 1 - len(self.invModulos))
        initialI = len(self.invModulos)
        for i in range(initialI, min(p, n + 1)):
            next = -self.invModulos[p % i] * (p // i) % p
            self.invModulos.append(next)
        return self.invModulos[pi]

    def invFactorial(self, n):
        if n <= -1:
            print("Invalid argument to calculate (n^(-1))!")
            print("n must be non-negative value. But the argument was " + str(n))
            exit()
        if n < len(self.invFactorial_):
            return self.invFactorial_[n]
        self.inv(n)  # To make sure already calculated n^-1
        nextArr = [0] * (n + 1 - len(self.invFactorial_))
        initialI = len(self.invFactorial_)
        prev = self.invFactorial_[-1]
        p = self.MOD
        for i in range(initialI, n + 1):
            prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
        self.invFactorial_ += nextArr
        return self.invFactorial_[n]

class Combination:
    def __init__(self, MOD):
        self.MOD = MOD
        self.factorial = Factorial(MOD)

    def ncr(self, n, k):
        if k < 0 or n < k:
            return 0
        k = min(k, n - k)
        f = self.factorial
        return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD

# --------------------------------------iye ha combinations ka zindegi---------------------------------
def powm(a, n, m):
    if a == 1 or n == 0:
        return 1
    if n % 2 == 0:
        s = powm(a, n // 2, m)
        return s * s % m
    else:
        return a * powm(a, n - 1, m) % m

# --------------------------------------iye ha power ka zindegi---------------------------------
def sort_list(list1, list2):
    zipped_pairs = zip(list2, list1)

    z = [x for _, x in sorted(zipped_pairs)]

    return z

# --------------------------------------------------product----------------------------------------
def product(l):
    por = 1
    for i in range(len(l)):
        por *= l[i]
    return por

# --------------------------------------------------binary----------------------------------------
def binarySearchCount(arr, n, key):
    left = 0
    right = n - 1

    count = 0

    while (left <= right):
        mid = int((right + left) / 2)

        # Check if middle element is
        # less than or equal to key
        if (arr[mid] < key):
            count = mid + 1
            left = mid + 1

        # If key is smaller, ignore right half
        else:
            right = mid - 1

    return count

# --------------------------------------------------binary----------------------------------------
def countdig(n):
    c = 0
    while (n > 0):
        n //= 10
        c += 1
    return c
def binary(x, length):
    y = bin(x)[2:]
    return y if len(y) >= length else "0" * (length - len(y)) + y

def countGreater(arr, n, k):
    l = 0
    r = n - 1

    # Stores the index of the left most element
    # from the array which is greater than k
    leftGreater = n

    # Finds number of elements greater than k
    while (l <= r):
        m = int(l + (r - l) / 2)
        if (arr[m] >= k):
            leftGreater = m
            r = m - 1

        # If mid element is less than
        # or equal to k update l
        else:
            l = m + 1

    # Return the count of elements
    # greater than k
    return (n - leftGreater)

# --------------------------------------------------binary------------------------------------
n=int(input())
ma=0
l=[]
time=[]
for i in range(n):
    s=list(map(int,input().split()))
    ma=max(ma,s[1])
    l.append(s+[i+1])
    time.append(s[1])
l=sort_list(l,time)
dp=[[[] for i in range(ma+1)]for j in range(n)]
dp1=[[0 for i in range(ma+1)]for j in range(n)]
for i in range(ma+1):
    if l[0][0]<=i<=l[0][1]:
        dp1[0][i]=l[0][2]
        dp[0][i]=[l[0][-1]]
for i in range(1,n):
    for j in range(ma+1):
        if j-l[i][0]>=0 and j<=l[i][1]:
            dp1[i][j]=max(dp1[i-1][j],dp1[i-1][j-l[i][0]]+l[i][2])
            if dp1[i][j]==dp1[i-1][j]:
                dp[i][j]=dp[i-1][j]+[]
            else:
                dp[i][j]=dp[i-1][j-l[i][0]-1]+[l[i][-1]]
        else:
            dp1[i][j]=dp1[i-1][j]
            dp[i][j]=dp[i-1][j]+[]
ans=max(dp1[-1])
print(ans)
ind=dp1[-1].index(ans)
print(len(dp[-1][ind]))
print(*dp[-1][ind])


# ---------------------------iye ha aam zindegi---------------------------------------------
import math
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
import sys
mod = 10 ** 9 + 7
mod1 = 998244353
#setrecursionlimit(300000)
# ------------------------------warmup----------------------------
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
sys.setrecursionlimit(300000)
class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")

sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

# -------------------game starts now----------------------------------------------------import math
class TreeNode:
    def __init__(self, k, v):
        self.key = k
        self.value = v
        self.left = None
        self.right = None
        self.parent = None
        self.height = 1
        self.num_left = 1
        self.num_total = 1

class AvlTree:

    def __init__(self):
        self._tree = None

    def add(self, k, v):
        if not self._tree:
            self._tree = TreeNode(k, v)
            return
        node = self._add(k, v)
        if node:
            self._rebalance(node)

    def _add(self, k, v):
        node = self._tree
        while node:
            if k < node.key:
                if node.left:
                    node = node.left
                else:
                    node.left = TreeNode(k, v)
                    node.left.parent = node
                    return node.left
            elif node.key < k:
                if node.right:
                    node = node.right
                else:
                    node.right = TreeNode(k, v)
                    node.right.parent = node
                    return node.right
            else:
                node.value = v
                return

    @staticmethod
    def get_height(x):
        return x.height if x else 0

    @staticmethod
    def get_num_total(x):
        return x.num_total if x else 0

    def _rebalance(self, node):

        n = node
        while n:
            lh = self.get_height(n.left)
            rh = self.get_height(n.right)
            n.height = max(lh, rh) + 1
            balance_factor = lh - rh
            n.num_total = 1 + self.get_num_total(n.left) + self.get_num_total(n.right)
            n.num_left = 1 + self.get_num_total(n.left)

            if balance_factor > 1:
                if self.get_height(n.left.left) < self.get_height(n.left.right):
                    self._rotate_left(n.left)
                self._rotate_right(n)
            elif balance_factor < -1:
                if self.get_height(n.right.right) < self.get_height(n.right.left):
                    self._rotate_right(n.right)
                self._rotate_left(n)
            else:
                n = n.parent

    def _remove_one(self, node):
        """
        Side effect!!! Changes node. Node should have exactly one child
        """
        replacement = node.left or node.right
        if node.parent:
            if AvlTree._is_left(node):
                node.parent.left = replacement
            else:
                node.parent.right = replacement
            replacement.parent = node.parent
            node.parent = None
        else:
            self._tree = replacement
            replacement.parent = None
        node.left = None
        node.right = None
        node.parent = None
        self._rebalance(replacement)

    def _remove_leaf(self, node):
        if node.parent:
            if AvlTree._is_left(node):
                node.parent.left = None
            else:
                node.parent.right = None
            self._rebalance(node.parent)
        else:
            self._tree = None
        node.parent = None
        node.left = None
        node.right = None

    def remove(self, k):
        node = self._get_node(k)
        if not node:
            return
        if AvlTree._is_leaf(node):
            self._remove_leaf(node)
            return
        if node.left and node.right:
            nxt = AvlTree._get_next(node)
            node.key = nxt.key
            node.value = nxt.value
            if self._is_leaf(nxt):
                self._remove_leaf(nxt)
            else:
                self._remove_one(nxt)
            self._rebalance(node)
        else:
            self._remove_one(node)

    def get(self, k):
        node = self._get_node(k)
        return node.value if node else -1

    def _get_node(self, k):
        if not self._tree:
            return None
        node = self._tree
        while node:
            if k < node.key:
                node = node.left
            elif node.key < k:
                node = node.right
            else:
                return node
        return None

    def get_at(self, pos):
        x = pos + 1
        node = self._tree
        while node:
            if x < node.num_left:
                node = node.left
            elif node.num_left < x:
                x -= node.num_left
                node = node.right
            else:
                return (node.key, node.value)
        raise IndexError("Out of ranges")

    @staticmethod
    def _is_left(node):
        return node.parent.left and node.parent.left == node

    @staticmethod
    def _is_leaf(node):
        return node.left is None and node.right is None

    def _rotate_right(self, node):
        if not node.parent:
            self._tree = node.left
            node.left.parent = None
        elif AvlTree._is_left(node):
            node.parent.left = node.left
            node.left.parent = node.parent
        else:
            node.parent.right = node.left
            node.left.parent = node.parent
        bk = node.left.right
        node.left.right = node
        node.parent = node.left
        node.left = bk
        if bk:
            bk.parent = node
        node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
        node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
        node.num_left = 1 + self.get_num_total(node.left)

    def _rotate_left(self, node):
        if not node.parent:
            self._tree = node.right
            node.right.parent = None
        elif AvlTree._is_left(node):
            node.parent.left = node.right
            node.right.parent = node.parent
        else:
            node.parent.right = node.right
            node.right.parent = node.parent
        bk = node.right.left
        node.right.left = node
        node.parent = node.right
        node.right = bk
        if bk:
            bk.parent = node
        node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
        node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
        node.num_left = 1 + self.get_num_total(node.left)

    @staticmethod
    def _get_next(node):
        if not node.right:
            return node.parent
        n = node.right
        while n.left:
            n = n.left
        return n

# -----------------------------------------------binary seacrh tree---------------------------------------
class SegmentTree1:
    def __init__(self, data, default=0, func=lambda a, b: max(a, b)):
        """initialize the segment tree with data"""
        self._default = default
        self._func = func
        self._len = len(data)
        self._size = _size = 1 << (self._len - 1).bit_length()

        self.data = [default] * (2 * _size)
        self.data[_size:_size + self._len] = data
        for i in reversed(range(_size)):
            self.data[i] = func(self.data[i + i], self.data[i + i + 1])

    def __delitem__(self, idx):
        self[idx] = self._default

    def __getitem__(self, idx):
        return self.data[idx + self._size]

    def __setitem__(self, idx, value):
        idx += self._size
        self.data[idx] = value
        idx >>= 1
        while idx:
            self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
            idx >>= 1

    def __len__(self):
        return self._len

    def query(self, start, stop):
        if start == stop:
            return self.__getitem__(start)
        stop += 1
        start += self._size
        stop += self._size

        res = self._default
        while start < stop:
            if start & 1:
                res = self._func(res, self.data[start])
                start += 1
            if stop & 1:
                stop -= 1
                res = self._func(res, self.data[stop])
            start >>= 1
            stop >>= 1
        return res

    def __repr__(self):
        return "SegmentTree({0})".format(self.data)

# -------------------game starts now----------------------------------------------------import math
class SegmentTree:
    def __init__(self, data, default=0, func=lambda a, b: a + b):
        """initialize the segment tree with data"""
        self._default = default
        self._func = func
        self._len = len(data)
        self._size = _size = 1 << (self._len - 1).bit_length()

        self.data = [default] * (2 * _size)
        self.data[_size:_size + self._len] = data
        for i in reversed(range(_size)):
            self.data[i] = func(self.data[i + i], self.data[i + i + 1])

    def __delitem__(self, idx):
        self[idx] = self._default

    def __getitem__(self, idx):
        return self.data[idx + self._size]

    def __setitem__(self, idx, value):
        idx += self._size
        self.data[idx] = value
        idx >>= 1
        while idx:
            self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
            idx >>= 1

    def __len__(self):
        return self._len

    def query(self, start, stop):
        if start == stop:
            return self.__getitem__(start)
        stop += 1
        start += self._size
        stop += self._size

        res = self._default
        while start < stop:
            if start & 1:
                res = self._func(res, self.data[start])
                start += 1
            if stop & 1:
                stop -= 1
                res = self._func(res, self.data[stop])
            start >>= 1
            stop >>= 1
        return res

    def __repr__(self):
        return "SegmentTree({0})".format(self.data)

# -------------------------------iye ha chutiya zindegi-------------------------------------
class Factorial:
    def __init__(self, MOD):
        self.MOD = MOD
        self.factorials = [1, 1]
        self.invModulos = [0, 1]
        self.invFactorial_ = [1, 1]

    def calc(self, n):
        if n <= -1:
            print("Invalid argument to calculate n!")
            print("n must be non-negative value. But the argument was " + str(n))
            exit()
        if n < len(self.factorials):
            return self.factorials[n]
        nextArr = [0] * (n + 1 - len(self.factorials))
        initialI = len(self.factorials)
        prev = self.factorials[-1]
        m = self.MOD
        for i in range(initialI, n + 1):
            prev = nextArr[i - initialI] = prev * i % m
        self.factorials += nextArr
        return self.factorials[n]

    def inv(self, n):
        if n <= -1:
            print("Invalid argument to calculate n^(-1)")
            print("n must be non-negative value. But the argument was " + str(n))
            exit()
        p = self.MOD
        pi = n % p
        if pi < len(self.invModulos):
            return self.invModulos[pi]
        nextArr = [0] * (n + 1 - len(self.invModulos))
        initialI = len(self.invModulos)
        for i in range(initialI, min(p, n + 1)):
            next = -self.invModulos[p % i] * (p // i) % p
            self.invModulos.append(next)
        return self.invModulos[pi]

    def invFactorial(self, n):
        if n <= -1:
            print("Invalid argument to calculate (n^(-1))!")
            print("n must be non-negative value. But the argument was " + str(n))
            exit()
        if n < len(self.invFactorial_):
            return self.invFactorial_[n]
        self.inv(n)  # To make sure already calculated n^-1
        nextArr = [0] * (n + 1 - len(self.invFactorial_))
        initialI = len(self.invFactorial_)
        prev = self.invFactorial_[-1]
        p = self.MOD
        for i in range(initialI, n + 1):
            prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
        self.invFactorial_ += nextArr
        return self.invFactorial_[n]

class Combination:
    def __init__(self, MOD):
        self.MOD = MOD
        self.factorial = Factorial(MOD)

    def ncr(self, n, k):
        if k < 0 or n < k:
            return 0
        k = min(k, n - k)
        f = self.factorial
        return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD

# --------------------------------------iye ha combinations ka zindegi---------------------------------
def powm(a, n, m):
    if a == 1 or n == 0:
        return 1
    if n % 2 == 0:
        s = powm(a, n // 2, m)
        return s * s % m
    else:
        return a * powm(a, n - 1, m) % m

# --------------------------------------iye ha power ka zindegi---------------------------------
def sort_list(list1, list2):
    zipped_pairs = zip(list2, list1)

    z = [x for _, x in sorted(zipped_pairs)]

    return z

# --------------------------------------------------product----------------------------------------
def product(l):
    por = 1
    for i in range(len(l)):
        por *= l[i]
    return por

# --------------------------------------------------binary----------------------------------------
def binarySearchCount(arr, n, key):
    left = 0
    right = n - 1

    count = 0

    while (left <= right):
        mid = int((right + left) / 2)

        # Check if middle element is
        # less than or equal to key
        if (arr[mid] < key):
            count = mid + 1
            left = mid + 1

        # If key is smaller, ignore right half
        else:
            right = mid - 1

    return count

# --------------------------------------------------binary----------------------------------------
def countdig(n):
    c = 0
    while (n > 0):
        n //= 10
        c += 1
    return c
def binary(x, length):
    y = bin(x)[2:]
    return y if len(y) >= length else "0" * (length - len(y)) + y

def countGreater(arr, n, k):
    l = 0
    r = n - 1

    # Stores the index of the left most element
    # from the array which is greater than k
    leftGreater = n

    # Finds number of elements greater than k
    while (l <= r):
        m = int(l + (r - l) / 2)
        if (arr[m] >= k):
            leftGreater = m
            r = m - 1

        # If mid element is less than
        # or equal to k update l
        else:
            l = m + 1

    # Return the count of elements
    # greater than k
    return (n - leftGreater)

# --------------------------------------------------binary------------------------------------
n=int(input())
ma=0
l=[]
time=[]
for i in range(n):
    s=list(map(int,input().split()))
    ma=max(ma,s[1])
    l.append(s+[i+1])
    time.append(s[1])
l=sort_list(l,time)
dp=[[[] for i in range(ma+1)]for j in range(n)]
dp1=[[0 for i in range(ma+1)]for j in range(n)]
for i in range(ma+1):
    if l[0][0]<=i<=l[0][1]:
        dp1[0][i]=l[0][2]
        dp[0][i]=[l[0][-1]]
for i in range(1,n):
    for j in range(ma+1):
        if j-l[i][0]>=0 and j<=l[i][1]:
            dp1[i][j]=max(dp1[i-1][j],dp1[i-1][j-l[i][0]]+l[i][2])
            if dp1[i][j]==dp1[i-1][j]:
                dp[i][j]=dp[i-1][j]+[]
            else:
                dp[i][j]=dp[i-1][j-l[i][0]]+[l[i][-1]]
        else:
            dp1[i][j]=dp1[i-1][j]
            dp[i][j]=dp[i-1][j]+[]
ans=max(dp1[-1])
print(ans)
ind=dp1[-1].index(ans)
print(len(dp[-1][ind]))
print(*dp[-1][ind])


from sys import stdin, stdout

n = int(stdin.readline())
items = []
for i in range(n):
  t,d,p = map(int,stdin.readline().split())
  items.append((d,p,t,i+1))
items.sort()

N = 2000+1
dp = [0 for i in range(N)]
cur = [[] for i in range(N)]
for d,p,t,it in items:
  for i in range(d-1,t-1,-1):
    if dp[i-t] + p > dp[i]:
      dp[i] = dp[i-t] + p
      cur[i] = cur[i-t] + [it]

best = 0
for i in range(N):
  if dp[i] > dp[best]:
    best = i

stdout.write('{}\n'.format(dp[best]))
stdout.write('{}\n'.format(len(cur[best])))
stdout.write(' '.join([str(x) for x in cur[best]]) + '\n')


from functools import lru_cache

def readints():
    return [int(obj) for obj in input().strip().split()]

class Solver:
    @lru_cache(maxsize=None)
    def f(self, last_item, total_sum):
        if last_item == 0:
            return [
                0,
                [],
            ]

        ans = 0
        res = []
        for d in range(0, total_sum + 1):
            if d - self.t[last_item] >= 0 and d < self.d[last_item] and self.t[last_item] < self.d[last_item]:
                data = self.f(last_item - 1, d - self.t[last_item])
                if data[0] + self.p[last_item] > ans:
                    ans = data[0] + self.p[last_item]
                    res = data[1] + [last_item]

            data = self.f(last_item - 1, d)
            if data[0] > ans:
                ans = data[0]
                res = data[1]

        return [
            ans,
            res,
        ]

    def main(self):
        n = readints()[0]
        self.t, self.d, self.p = [], [], []
        for i in range(n):
            t1, d1, p1 = readints()
            self.t.append(t1)
            self.d.append(d1)
            self.p.append(p1)
        triples = zip(self.t, self.d, self.p, range(1, n+1))
        triples = sorted(triples, key=lambda x: x[1])
        self.t, self.d, self.p, self.indexes = [0], [0], [0], []
        for i in range(n):
            self.t.append(triples[i][0])
            self.d.append(triples[i][1])
            self.p.append(triples[i][2])
            self.indexes.append(triples[i][3])

        ans = 0
        res = []
        for i in range(sum(self.d) + 1):
            data = self.f(n, i)
            if data[0] > ans:
                ans = data[0]
                res = data[1]

        print(ans)
        print(len(res))
        print(' '.join(str(self.indexes[item - 1]) for item in res))

Solver().main()


from functools import lru_cache

def readints():
    return [int(obj) for obj in input().strip().split()]

class Solver:
    @lru_cache(maxsize = None)
    def f(self, last_item, total_sum):
        if last_item == 0:
            return 0

        ans = 0
        for d in range(0, total_sum + 1):
            if d - self.t[last_item] >= 0 and d < self.d[last_item] and self.t[last_item] < self.d[last_item]:
                data = self.f(last_item - 1, d - self.t[last_item])
                if data + self.p[last_item] > ans:
                    ans = data + self.p[last_item]
                    self.backtrack[last_item][total_sum] = last_item

            data = self.f(last_item - 1, d)
            if data > ans:
                ans = data
                self.backtrack[last_item][total_sum] = 0

        return ans

    def main(self):
        n = readints()[0]
        self.t, self.d, self.p = [], [], []
        for i in range(n):
            t1, d1, p1 = readints()
            self.t.append(t1)
            self.d.append(d1)
            self.p.append(p1)

        self.backtrack = []
        sd = sum(self.d) + 1
        for i in range(n+1):
            self.backtrack.append([])
            for j in range(sd):
                self.backtrack[i].append(0)

        triples = zip(self.t, self.d, self.p, range(1, n+1))
        triples = sorted(triples, key=lambda x: x[1])
        self.t, self.d, self.p, self.indexes = [0], [0], [0], []
        for i in range(n):
            self.t.append(triples[i][0])
            self.d.append(triples[i][1])
            self.p.append(triples[i][2])
            self.indexes.append(triples[i][3])

        ans = 0
        res = []
        best = None
        for i in range(sum(self.d) + 1):
            data = self.f(n, i)
            if data > ans:
                ans = data
                best = (n, i)

        i = best[0]
        s = best[1]
        while i > 0:
            if self.backtrack[i][s] != 0:
                res.append(self.backtrack[i][s])
                s -= self.backtrack[i][s]
            i -= 1

        print(ans)
        print(len(res))
        print(' '.join(str(self.indexes[item - 1]) for item in reversed(res)))

Solver().main()


from functools import lru_cache

def readints():
    return [int(obj) for obj in input().strip().split()]

class Solver:
    @lru_cache(maxsize=None)
    def f(self, last_item, total_sum):
        if last_item == 0:
            return {
                'value': 0,
                'items': [],
            }

        ans = 0
        res = []
        for d in range(0, total_sum + 1):
            if d - self.t[last_item] >= 0 and d < self.d[last_item] and self.t[last_item] < self.d[last_item]:
                data = self.f(last_item - 1, d - self.t[last_item])
                if data['value'] + self.p[last_item] > ans:
                    ans = data['value'] + self.p[last_item]
                    res = data['items'] + [last_item]

            data = self.f(last_item - 1, d)
            if data['value'] > ans:
                ans = data['value']
                res = data['items']

        return {
            'value': ans,
            'items': res,
        }

    def main(self):
        n = readints()[0]
        self.t, self.d, self.p = [], [], []
        for i in range(n):
            t1, d1, p1 = readints()
            self.t.append(t1)
            self.d.append(d1)
            self.p.append(p1)
        triples = zip(self.t, self.d, self.p, range(1, n+1))
        triples = sorted(triples, key=lambda x: x[1])
        self.t, self.d, self.p, self.indexes = [0], [0], [0], []
        for i in range(n):
            self.t.append(triples[i][0])
            self.d.append(triples[i][1])
            self.p.append(triples[i][2])
            self.indexes.append(triples[i][3])

        ans = 0
        res = []
        for i in range(sum(self.d) + 1):
            data = self.f(n, i)
            if data['value'] > ans:
                ans = data['value']
                res = data['items']

        print(ans)
        print(len(res))
        print(' '.join(str(self.indexes[item - 1]) for item in res))

Solver().main()


from functools import lru_cache

def readints():
    return [int(obj) for obj in input().strip().split()]

class Solver:
    @lru_cache(maxsize=None)
    def f(self, last_item, total_sum):
        if last_item == 0:
            return {
                'value': 0,
                'items': [],
            }

        ans = 0
        res = []
        for d in range(0, total_sum + 1):
            if d - self.t[last_item] >= 0 and d < self.d[last_item] and self.t[last_item] < self.d[last_item]:
                data = self.f(last_item - 1, d - self.t[last_item])
                if data['value'] + self.p[last_item] > ans:
                    ans = data['value'] + self.p[last_item]
                    res = data['items'] + [last_item]

            data = self.f(last_item - 1, d)
            if data['value'] > ans:
                ans = data['value']
                res = data['items']

        return {
            'value': ans,
            'items': res,
        }

    def main(self):
        n = readints()[0]
        self.t, self.d, self.p = [], [], []
        for i in range(n):
            t1, d1, p1 = readints()
            self.t.append(t1)
            self.d.append(d1)
            self.p.append(p1)
        triples = zip(self.t, self.d, self.p, range(1, n+1))
        triples = sorted(triples, key=lambda x: x[1])
        self.t, self.d, self.p, self.indexes = [0], [0], [0], []
        for i in range(n):
            self.t.append(triples[i][0])
            self.d.append(triples[i][1])
            self.p.append(triples[i][2])
            self.indexes.append(triples[i][3])

        ans = 0
        res = []
        for i in range(max(self.d) + 1):
            data = self.f(n, i)
            if data['value'] > ans:
                ans = data['value']
                res = data['items']

        print(ans)
        print(len(res))
        print(' '.join(str(self.indexes[item - 1]) for item in res))

Solver().main()


from functools import lru_cache

def readints():
    return [int(obj) for obj in input().strip().split()]

class Solver:
    @lru_cache(maxsize=None)
    def f(self, last_item, total_sum):
        if last_item == 0:
            return 0

        ans = 0
        for d in range(0, total_sum + 1):
            if d - self.t[last_item] >= 0 and d < self.d[last_item] and self.t[last_item] < self.d[last_item]:
                data = self.f(last_item - 1, d - self.t[last_item])
                if data + self.p[last_item] > ans:
                    ans = data + self.p[last_item]
                    self.backtrack[last_item][total_sum] = last_item

            data = self.f(last_item - 1, d)
            if data > ans:
                ans = data
                self.backtrack[last_item][total_sum] = 0

        return ans

    def main(self):
        n = readints()[0]
        self.t, self.d, self.p = [], [], []
        for i in range(n):
            t1, d1, p1 = readints()
            self.t.append(t1)
            self.d.append(d1)
            self.p.append(p1)

        self.backtrack = []
        sd = sum(self.d) + 1
        for i in range(n+1):
            self.backtrack.append([])
            for j in range(sd):
                self.backtrack[i].append(0)

        triples = zip(self.t, self.d, self.p, range(1, n+1))
        triples = sorted(triples, key=lambda x: x[1])
        self.t, self.d, self.p, self.indexes = [0], [0], [0], []
        for i in range(n):
            self.t.append(triples[i][0])
            self.d.append(triples[i][1])
            self.p.append(triples[i][2])
            self.indexes.append(triples[i][3])

        ans = 0
        res = []
        best = None
        for i in range(sum(self.d) + 1):
            data = self.f(n, i)
            if data > ans:
                ans = data
                best = (n, i)

        i = best[0]
        s = best[1]
        while i > 0:
            if self.backtrack[i][s] != 0:
                res.append(self.backtrack[i][s])
                s -= self.backtrack[i][s]
            i -= 1

        print(ans)
        print(len(res))
        print(' '.join(str(self.indexes[item - 1]) for item in reversed(res)))

Solver().main()


from functools import lru_cache

def readints():
    return [int(obj) for obj in input().strip().split()]

class Solver:
    def main(self):
        n = readints()[0]
        self.t, self.d, self.p = [], [], []
        for i in range(n):
            t1, d1, p1 = readints()
            self.t.append(t1)
            self.d.append(d1)
            self.p.append(p1)

        self.backtrack = []
        sd = sum(self.d) + 1
        for i in range(n+1):
            self.backtrack.append([])
            for j in range(sd):
                self.backtrack[i].append(0)

        triples = zip(self.t, self.d, self.p, range(1, n+1))
        triples = sorted(triples, key=lambda x: x[1])
        self.t, self.d, self.p, self.indexes = [0], [0], [0], [0]
        for i in range(n):
            self.t.append(triples[i][0])
            self.d.append(triples[i][1])
            self.p.append(triples[i][2])
            self.indexes.append(triples[i][3])

        self.f = []
        for i in range(n+1):
            self.f.append([])
            for j in range(sd):
                self.f[i].append(0)

        for i in range(1, n+1):
            for d in range(sd):
                if d - self.t[i] >= 0 and d < self.d[i] and self.t[i] < self.d[i]:
                    data = self.f[i - 1][d - self.t[i]]
                    if data + self.p[i] > self.f[i][d]:
                        self.f[i][d] = data + self.p[i]
                        self.backtrack[i][d] = i

                data = self.f[i - 1][d]
                if data > self.f[i][d]:
                    self.f[i][d] = data
                    self.backtrack[i][d] = 0

        ans = 0
        res = []
        best = None
        for i in range(sd):
            data = self.f[n][i]
            if data > ans:
                ans = data
                best = (n, i)

        i = best[0]
        s = best[1]
        while i > 0:
            if self.backtrack[i][s] != 0:
                res.append(self.backtrack[i][s])
                s -= self.t[self.backtrack[i][s]]
            i -= 1

        print(ans)
        print(len(res))
        print(' '.join(str(self.indexes[item - 1]) for item in reversed(res)))

Solver().main()


from functools import lru_cache

def readints():
    return [int(obj) for obj in input().strip().split()]

class Solver:
    def main(self):
        n = readints()[0]
        self.t, self.d, self.p = [], [], []
        for i in range(n):
            t1, d1, p1 = readints()
            self.t.append(t1)
            self.d.append(d1)
            self.p.append(p1)

        self.backtrack = []
        sd = sum(self.d) + 1
        for i in range(n+1):
            self.backtrack.append([])
            for j in range(sd):
                self.backtrack[i].append(0)

        triples = zip(self.t, self.d, self.p, range(1, n+1))
        triples = sorted(triples, key=lambda x: x[1])
        self.t, self.d, self.p, self.indexes = [0], [0], [0], []
        for i in range(n):
            self.t.append(triples[i][0])
            self.d.append(triples[i][1])
            self.p.append(triples[i][2])
            self.indexes.append(triples[i][3])

        self.f = []
        for i in range(n+1):
            self.f.append([])
            for j in range(sd):
                self.f[i].append(0)

        for i in range(1, n+1):
            for d in range(sd):
                if d - self.t[i] >= 0 and d < self.d[i] and self.t[i] < self.d[i]:
                    data = self.f[i - 1][d - self.t[i]]
                    if data + self.p[i] > self.f[i][d]:
                        self.f[i][d] = data + self.p[i]
                        self.backtrack[i][d] = i

                data = self.f[i - 1][d]
                if data > self.f[i][d]:
                    self.f[i][d] = data
                    self.backtrack[i][d] = 0

        ans = 0
        res = []
        best = None
        for i in range(sd):
            data = self.f[n][i]
            if data > ans:
                ans = data
                best = (n, i)

        i = best[0]
        s = best[1]
        while i > 0:
            if self.backtrack[i][s] != 0:
                res.append(self.backtrack[i][s])
                s -= self.t[self.backtrack[i][s]]
            i -= 1

        print(ans)
        print(len(res))
        print(' '.join(str(self.indexes[item - 1]) for item in reversed(res)))

Solver().main()


from functools import lru_cache

def readints():
    return [int(obj) for obj in input().strip().split()]

class Solver:
    def main(self):
        n = readints()[0]
        self.t, self.d, self.p = [], [], []
        for i in range(n):
            t1, d1, p1 = readints()
            self.t.append(t1)
            self.d.append(d1)
            self.p.append(p1)

        self.backtrack = []
        sd = max(self.d) + 1
        for i in range(n+1):
            self.backtrack.append([])
            for j in range(sd):
                self.backtrack[i].append(0)

        triples = zip(self.t, self.d, self.p, range(1, n+1))
        triples = sorted(triples, key=lambda x: x[1])
        self.t, self.d, self.p, self.indexes = [0], [0], [0], []
        for i in range(n):
            self.t.append(triples[i][0])
            self.d.append(triples[i][1])
            self.p.append(triples[i][2])
            self.indexes.append(triples[i][3])

        self.f = []
        for i in range(n+1):
            self.f.append([])
            for j in range(sd):
                self.f[i].append(0)

        for i in range(1, n+1):
            for d in range(sd):
                if d - self.t[i] >= 0 and d < self.d[i] and self.t[i] < self.d[i]:
                    data = self.f[i - 1][d - self.t[i]]
                    if data + self.p[i] > self.f[i][d]:
                        self.f[i][d] = data + self.p[i]
                        self.backtrack[i][d] = i

                data = self.f[i - 1][d]
                if data > self.f[i][d]:
                    self.f[i][d] = data
                    self.backtrack[i][d] = 0

        ans = 0
        res = []
        best = None
        for i in range(sd):
            data = self.f[n][i]
            if data > ans:
                ans = data
                best = (n, i)

        i = best[0]
        s = best[1]
        while i > 0:
            if self.backtrack[i][s] != 0:
                res.append(self.backtrack[i][s])
                s -= self.t[self.backtrack[i][s]]
            i -= 1

        print(ans)
        print(len(res))
        print(' '.join(str(self.indexes[item - 1]) for item in reversed(res)))

Solver().main()


from functools import lru_cache

def readints():
    return [int(obj) for obj in input().strip().split()]

class Solver:
    @lru_cache(maxsize=None)
    def f(self, last_item, total_sum):
        if last_item == 0:
            return {
                'value': 0,
                'items': [],
            }

        ans = 0
        res = []
        for d in range(0, total_sum + 1):
            if (0 <= d - self.t[last_item] < self.d[last_item] and
                        self.t[last_item] < self.d[last_item]):
                data = self.f(last_item - 1, d - self.d[last_item])
                if data['value'] + self.p[last_item] > ans:
                    ans = data['value'] + self.p[last_item]
                    res = data['items'] + [last_item]

            data = self.f(last_item - 1, d)
            if data['value'] > ans:
                ans = data['value']
                res = data['items']

        return {
            'value': ans,
            'items': res,
        }

    def main(self):
        n = readints()[0]
        self.t, self.d, self.p = [0], [0], [0]
        for i in range(n):
            t1, d1, p1 = readints()
            self.t.append(t1)
            self.d.append(d1)
            self.p.append(p1)

        ans = 0
        res = []
        for i in range(sum(self.d) + 1):
            data = self.f(n, i)
            if data['value'] > ans:
                ans = data['value']
                res = data['items']

        print(ans)
        print(len(res))
        print(' '.join(str(item) for item in res))

Solver().main()


from functools import lru_cache

def readints():
    return [int(obj) for obj in input().strip().split()]

class Solver:
    @lru_cache(maxsize=None)
    def f(self, last_item, total_sum):
        if last_item == 0:
            return 0

        ans = 0
        for d in range(0, total_sum + 1):
            if d - self.t[last_item] >= 0 and d < self.d[last_item] and self.t[last_item] < self.d[last_item]:
                data = self.f(last_item - 1, d - self.t[last_item])
                if data + self.p[last_item] > ans:
                    ans = data + self.p[last_item]
                    self.backtrack[last_item][total_sum] = last_item

            data = self.f(last_item - 1, d)
            if data > ans:
                ans = data
                self.backtrack[last_item][total_sum] = 0

        return ans

    def main(self):
        n = readints()[0]
        self.t, self.d, self.p = [], [], []
        for i in range(n):
            t1, d1, p1 = readints()
            self.t.append(t1)
            self.d.append(d1)
            self.p.append(p1)

        self.backtrack = []
        sd = sum(self.d) + 1
        for i in range(n+1):
            self.backtrack.append([])
            for j in range(sd):
                self.backtrack[i].append(0)

        triples = zip(self.t, self.d, self.p, range(1, n+1))
        triples = sorted(triples, key=lambda x: x[1])
        self.t, self.d, self.p, self.indexes = [0], [0], [0], []
        for i in range(n):
            self.t.append(triples[i][0])
            self.d.append(triples[i][1])
            self.p.append(triples[i][2])
            self.indexes.append(triples[i][3])

        ans = 0
        res = []
        best = None
        for i in range(max(self.d) + 1):
            data = self.f(n, i)
            if data > ans:
                ans = data
                best = (n, i)

        i = best[0]
        s = best[1]
        while i > 0:
            if self.backtrack[i][s] != 0:
                res.append(self.backtrack[i][s])
                s -= self.backtrack[i][s]
            i -= 1

        print(ans)
        print(len(res))
        print(' '.join(str(self.indexes[item - 1]) for item in reversed(res)))

Solver().main()