'Create a list of new VFG jobs for the successor state.
:param VFGJob job:                 The VFGJob instance.
:param SimState successor: The succeeding state.
:param BlockID new_block_id:       Block ID for the new VFGJob
:param new_call_stack:             The new callstack.
:return:                           A list of newly created VFG jobs.
:rtype:                            list'

def _create_new_jobs(self, job, successor, new_block_id, new_call_stack):

    jumpkind = successor.history.jumpkind
    successor_state = successor.copy()
    successor_addr = successor_state.se.any_int(successor_state.ip)
    new_jobs = []
    if (jumpkind == 'Ijk_FakeRet'):
        assert job.is_call_jump
        if (self._cfg is not None):
            current_function = self.kb.functions.function(job.call_target)
            if (current_function is not None):
                sp_difference = current_function.sp_delta
            else:
                sp_difference = 0
            reg_sp_offset = successor_state.arch.sp_offset
            reg_sp_expr = (successor_state.registers.load(reg_sp_offset) + sp_difference)
            successor_state.registers.store(successor_state.arch.sp_offset, reg_sp_expr)
            top_si = successor_state.se.TSI(successor_state.arch.bits)
            successor_state.registers.store(successor_state.arch.ret_offset, top_si)
        if job.call_skipped:
            new_job = VFGJob(successor_addr, successor_state, self._context_sensitivity_level, block_id=new_block_id, jumpkind='Ijk_Ret', call_stack=new_call_stack)
            new_jobs.append(new_job)
            assert isinstance(self._task_stack[(-2)], FunctionAnalysis)
            self._task_stack[(-2)].jobs.append(new_job)
            job.dbg_exit_status[successor] = 'Pending'
        else:
            self._pending_returns[new_block_id] = (successor_state, new_call_stack)
            job.dbg_exit_status[successor] = 'Pending'
    else:
        if (sim_options.ABSTRACT_MEMORY in successor.options):
            if self._is_call_jumpkind(successor.history.jumpkind):
                reg_sp_si = self._create_stack_region(successor_state, successor_addr)
                new_reg_sp_expr = successor_state.se.ValueSet(successor_state.arch.bits, 'global', 0, reg_sp_si)
                successor_state.regs.sp = new_reg_sp_expr
            elif (successor.history.jumpkind == 'Ijk_Ret'):
                reg_sp_expr = successor_state.regs.sp
                if isinstance(reg_sp_expr._model_vsa, claripy.vsa.StridedInterval):
                    reg_sp_si = reg_sp_expr._model_vsa
                    reg_sp_val = reg_sp_si.min
                elif isinstance(reg_sp_expr._model_vsa, claripy.vsa.ValueSet):
                    reg_sp_si = reg_sp_expr._model_vsa.items()[0][1]
                    reg_sp_val = reg_sp_si.min
        new_job = VFGJob(successor_addr, successor_state, self._context_sensitivity_level, block_id=new_block_id, jumpkind=successor_state.history.jumpkind, call_stack=new_call_stack)
        if (successor.history.jumpkind == 'Ijk_Ret'):
            if self._record_function_final_states:
                source_function_key = FunctionKey.new(job.func_addr, job.call_stack_suffix)
                self._save_function_final_state(source_function_key, job.func_addr, successor_state)
            current_task = self._top_task
            if (current_task.call_analysis is not None):
                current_task.call_analysis.add_final_job(new_job)
                job.dbg_exit_status[successor] = 'Appended    to    the    call    analysis    task'
            else:
                job.dbg_exit_status[successor] = 'Discarded    (no    call    analysis    task)'
        else:
            if self._is_call_jumpkind(successor.history.jumpkind):
                task = FunctionAnalysis(new_job.addr, None)
                self._task_stack.append(task)
                job.call_task.register_function_analysis(task)
            else:
                task = self._top_task
            task.jobs.append(new_job)
            new_jobs.append(new_job)
            job.dbg_exit_status[successor] = 'Appended'
    if ((not job.is_call_jump) or (jumpkind != 'Ijk_FakeRet')):
        new_target = (new_block_id, jumpkind)
    else:
        new_target = (new_block_id, 'Ijk_FakeRet')
    self._exit_targets[(job.call_stack_suffix + (job.addr,))].append(new_target)
    return new_jobs
