def append_instruction(self, instruction: SimulationInstruction, recalculate_resulting_cube_state: bool = True):
    """Appends a given instruction to the end of the program.

    Args:
        instruction: the instruction to append
        recalculate_resulting_cube_state: flag, indicating whether to immediately recalculate the resulting cube state or post pone it to the next access
    """

    assert isinstance(instruction, SimulationInstruction)

    if recalculate_resulting_cube_state:
        self._resulting_cube_state = instruction.apply_to_cube_state(self.resulting_cube_state())
    else:
        self._resulting_cube_state = None

    self.instructions.append(instruction)
    logger.debug('{}: Added {}'.format(self.name, instruction))

def append_instructions(self, instructions: List[SimulationInstruction], recalculate_resulting_cube_state: bool = True):
    """Appends a given set of instructions to the end of the program.

    Args:
        instructions: the instructions to append
        recalculate_resulting_cube_state: flag, indicating whether to immediately recalculate the resulting cube state or post pone it to the next access
    """

    assert isinstance(instructions, list)
    if len(instructions) < 0:
        return

    for instruction in instructions:
        assert isinstance(instruction, SimulationInstruction)
        logger.debug('{}: Added {}'.format(self.name, instruction))

    if recalculate_resulting_cube_state:
        state = self.resulting_cube_state()
        for instruction in instructions:
            state = instruction.apply_to_cube_state(state)
        self._resulting_cube_state = state
    else:
        self._resulting_cube_state = None

    self.instructions += instructions

def create_follow_up(self, name: str) -> 'SimulationProgram':
    """Creates a follow-up program.

    The newly created simulation program has this program as its parent
    and the resulting robot position as its initial robot position.

    Args:
        name: the name of the follow-up program

    Returns:
        the follow-up
    """
    return SimulationProgram(name, parent=self, initial_robot_joints=self.final_robot_position())

def execute(self):
    """Executes the program through python including all parent instructions."""

    if self.has_parent:
        assert isinstance(self.parent, SimulationProgram)
        self.parent.execute()

    logger.info('Executing {} -> {} instructions to go.'.format(self.name, len(self.instructions)))

    follow_along_cube_state = self.initial_cube_state
    for instruction in self.instructions:
        if logger.isEnabledFor(logging.DEBUG):
            logger.info('\tExecuting {}.'.format(instruction.name))

            if isinstance(instruction, GripInstruction):
                logger.debug('\t\t from: {}'.format(str(follow_along_cube_state)))

            follow_along_cube_state = instruction.apply_to_cube_state(follow_along_cube_state)

            if isinstance(instruction, GripInstruction):
                logger.debug('\t\t to:   {}'.format(str(follow_along_cube_state)))

        instruction.execute()

def final_robot_position(self) -> List[float]:
    """Returns the robot joints after the program was run.

    Returns:
        the robot joints of the last `MoveInstruction` in the instruction list.
    """
    for i in range(len(self.instructions) - 1, -1, -1):
        instruction = self.instructions[i]
        if isinstance(instruction, MoveInstruction):
            return instruction.target.Joints().list()

    return self.initial_robot_joints

def flattened_standalone(self, name: str) -> 'SimulationProgram':
    """Creates a standalone program.

     All instructions including those of its parents are deepcopied and added to the standalone.

    Args:
        name: the name of the flattened program

    Returns:
        the flattened program
    """

    if not self.has_parent:
        copy = SimulationProgram(name, initial_cube_state=deepcopy(self.initial_cube_state), parent=None)
        copy.append_instructions(deepcopy(self.instructions))
        return copy

    flattened_standalone_program = self.parent.flattened_standalone(name)
    flattened_standalone_program.append_instructions(self.instructions)
    return flattened_standalone_program

def get_unchecked_collision_checking_programs(self) -> List['SimulationProgram']:
    """Returns all unchecked programs in the current hierarchy path (i.e. including unchecked parents).

    Returns:
        the unchecked programs
    """
    programs: List['SimulationProgram'] = []
    if self.has_parent:
        programs = self.parent.get_unchecked_collision_checking_programs()

    if not self.collision_check_is_done:
        programs.append(self)

    return programs

def resulting_cube_state(self) -> CubeState:
    """Calculates the state of the cube when the program was run.

    Returns:
        the resulting cube state
    """

    if self._resulting_cube_state is None:
        state = self.initial_cube_state
        for instruction in self.instructions:
            state = instruction.apply_to_cube_state(state)
        self._resulting_cube_state = state

    return self._resulting_cube_state

def evaluate(self) -> SimulationResult:
    """Sets up the program and performs a collision checking evaluation.

    Returns:
        the simulation result
    """

    self.setup()

    robot = RoboDKInterface.link.Item('', robolink.ITEM_TYPE_ROBOT)
    current_joints = robot.Joints()
    robot.setJoints(self.simulation_program.initial_robot_joints)
    result = self.program.Update(check_collisions=True)
    sim_result = SimulationResult(
        num_valid_instructions=result[0],
        time=result[1],
        distance=result[2],
        path_validity_percentage=result[3],
        message=result[4]
    )
    if sim_result.path_validity_percentage < 1:
        for pair in RoboDKInterface.link.CollisionPairs():
            logger.debug('Collision: | ' + ' | '.join(map(lambda item: item.Name(), pair[:2])))

    robot.setJoints(current_joints)
    return sim_result

def execute(self, teardown_on_done: bool = True):
    """Executes the program through RoboDK."""

    result = self.evaluate()
    logger.debug('Running Program: {}'.format(result))
    self.program.RunProgram()

    if teardown_on_done:
        logger.debug('tearing down')
        self.teardown()
    return result

@classmethod
def perform_remaining_collision_checks(cls, simulation_program: SimulationProgram, program_name_prefix: str = None):
    """Performs collision checking on the untested portions of the given simulation program.
    The results of each simulation program will be set afterwards.
    """
    programs_to_check = simulation_program.get_unchecked_collision_checking_programs()
    for program_to_check in programs_to_check:
        program = cls(program_to_check, f'{program_name_prefix}_{program_to_check.name}')
        result = program.evaluate()
        program.teardown()
        program_to_check.set_collision_checking_result(result)

def setup(self):
    """Prepares the program for evaluation.

    Creates a fresh RoboDK Program and adds the instructions of the simulation program to it.
    """

    self.teardown()

    self.program = RoboDKInterface.link.AddProgram(self.program_name)
    if not self.program.Valid():
        self.teardown()
        raise ValueError('Couldnt create simulation program.')

    assert isinstance(self.program, robolink.Item)
    assert self.program.Valid()
    assert self.program.Type() == robolink.ITEM_TYPE_PROGRAM

    for instruction in self.simulation_program.instructions:
        instruction.add_to_program(self.program)

def teardown(self):
    """Deletes the program from the RoboDK item tree."""

    program = self.program if self.program is not None else RoboDKInterface.link.Item(self.program_name)
    if program.Valid():
        assert program.Type() == robolink.ITEM_TYPE_PROGRAM
        program.Delete()

    self.program = None