docs: def _get_symbolic_function_initial_state(self, function_addr, fastpath_mode_state=None):
          """
          Symbolically execute the first basic block of the specified function,
          then returns it. We prepares the state using the already existing
          state in fastpath mode (if avaiable).
          :param function_addr: The function address
          :return: A symbolic state if succeeded, None otherwise
          """
          if function_addr is None:
              return None
  
          if function_addr in self._symbolic_function_initial_state:
              return self._symbolic_function_initial_state[function_addr]
  
          if fastpath_mode_state is not None:
              fastpath_state = fastpath_mode_state
          else:
              if function_addr in self._function_input_states:
                  fastpath_state = self._function_input_states[function_addr]
              else:
                  raise AngrCFGError('The impossible happened. Please report to Fish.')
  
          symbolic_initial_state = self.project.factory.entry_state(mode='symbolic')
          if fastpath_state is not None:
              symbolic_initial_state = self.project.simos.prepare_call_state(fastpath_state,
                                                                              initial_state=symbolic_initial_state)
  
          # Find number of instructions of start block
          func = self.project.kb.functions.get(function_addr)
          start_block = func._get_block(function_addr)
          num_instr = start_block.instructions - 1
  
          symbolic_initial_state.ip = function_addr
          path = self.project.factory.path(symbolic_initial_state)
          try:
              sim_successors = self.project.factory.successors(path.state, num_inst=num_instr)
          except (SimError, AngrError):
              return None
  
          # We execute all but the last instruction in this basic block, so we have a cleaner
          # state
          # Start execution!
          exits = sim_successors.flat_successors + sim_successors.unsat_successors
  
          if exits:
              final_st = None
              for ex in exits:
                  if ex.satisfiable():
                      final_st = ex
                      break
          else:
              final_st = None
  
          self._symbolic_function_initial_state[function_addr] = final_st
  
          return final_st