<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
 def start_child_states(self, concurrency_history_item, do_not_start_state=None):
 """ Utility function to start all child states of the concurrency state. :param concurrency_history_item: each concurrent child branch gets an execution history stack of this concurrency history item :param do_not_start_state: optionally the id of a state can be passed, that must not be started (e.g. in the case of the barrier concurrency state the decider state) :return: """

        self.state_execution_status = StateExecutionStatus.EXECUTE_CHILDREN
        # actually the queue is not needed in the barrier concurrency case
        # to avoid code duplication both concurrency states have the same start child function
        concurrency_queue = queue.Queue(maxsize=0)  # infinite Queue size

        for index, state in enumerate(self.states.values()):
            if state is not do_not_start_state:

                state.input_data = self.get_inputs_for_state(state)
                state.output_data = self.create_output_dictionary_for_state(state)
                state.concurrency_queue = concurrency_queue
                state.concurrency_queue_id = index

                state.generate_run_id()
                if not self.backward_execution:
                    # care for the history items; this item is only for execution visualization
                    concurrency_history_item.execution_histories[index].push_call_history_item(
                        state, CallType.EXECUTE, self, state.input_data)
                else:  # backward execution
                    last_history_item = concurrency_history_item.execution_histories[index].pop_last_item()
                    assert isinstance(last_history_item, ReturnItem)
                state.start(concurrency_history_item.execution_histories[index], self.backward_execution, False)

        return concurrency_queue