def get_packing_strategies(start_length, minimum_increment, target_length, depth):
    """Recursively build a list of unique packing "strategies".

    These strategies represent the ways that up to "depth" many sequences can
    be packed together to produce a packed sequence of exactly "target_length"
    tokens in total. For example [1, 2, 509] represent the packing strategy of
    combining a sequence of length 1, a sequence of length 2, and sequence of
    length 509 to create one packed sequence of length 512.

    To ensure strategies are unique, each sequence added to the pack must be
    at least as long as the previous sequence added to the pack. This is
    tracked through the "minimum_increment" variable and results in the
    strategies containing sequence lengths in sorted order e.g. [1, 2, 509]
    but not [2, 1, 509]

    Parameters
    ----------
    start_length : int
      The current cumulative number of tokens in the pack.
      Typically initalized to 0.
    minimum_increment : int
      The minimum length of the next sequence can be added to the pack.
      Typically initialized to 1.
    target_length : int
      The target_length for a pack of sequences (e.g. 512).
    depth : int
      Remaining depth in the recursion (must be > 0).

    Returns
    -------
    strategies : list[list[int]]
      A list of strategies where each strategy is a list of integers
      representing sequence lengths of the components in the pack. Each
      strategy should have at most "depth" entries and sum up to "target_length".
    """
    gap = target_length - start_length
    strategies = []

    # Complete the packing with exactly 1 number
    if depth == 1:
        if gap >= minimum_increment:
            strategies.append([gap])

    # Complete the sample in "depth" steps, recursively
    else:
        for new in range(minimum_increment, gap + 1):
            new_gap = target_length - start_length - new
            if new_gap == 0:
                strategies.append([new])
            else:
                options = get_packing_strategies(start_length + new, new, target_length, depth - 1)
                for option in options:
                    if len(option) > 0:
                        strategies.append([new] + option)
    return strategies