Simplify all function call statements.

        :return:    None
760834
def _make_callsites(self, stack_pointer_tracker=None):
        

        # Computing reaching definitions
        rd = self.project.analyses.ReachingDefinitions(func=self.function, func_graph=self.graph, observe_all=True)

        for key in self._blocks:
            block = self._blocks[key]
            csm = self.project.analyses.AILCallSiteMaker(block, reaching_definitions=rd)
            if csm.result_block:
                ail_block = csm.result_block
                simp = self.project.analyses.AILBlockSimplifier(ail_block, stack_pointer_tracker=stack_pointer_tracker)
                self._blocks[key] = simp.result_block

        self._update_graph()
1063050
def disable_checker_on_env(func):
    
    @wraps(func)
    def func_wrapper(*args, **kwargs):
        # pylint: disable=C0111, C0103
        function_name = func.__name__
        CHECKERS_DISABLED = os.getenv('CHECKERS_DISABLED', '')
        disabled_functions = [x.strip() for x in CHECKERS_DISABLED.split(',')]

        force_run = kwargs.get('force_run', False)

        if function_name in disabled_functions and not force_run:
            return True
        else:
            return func(*args, **kwargs)

    return func_wrapper
361269
def mute(func):
    
    def _f(*args, **kwargs):
        sys.stdout = open(os.devnull, 'w')
        res = func(*args, **kwargs)
        sys.stdout.close()
        sys.stdout = sys.__stdout__
        return res
    return _f
715695
def reduce(function, initval=None):
	
	if initval is None:
		return lambda s: __builtin__.reduce(function, s)
	else:
		return lambda s: __builtin__.reduce(function, s, initval)
910414
def __normalize_args(**keywds):
        """"""
        if isinstance(keywds['name'], Callable) and \
                None is keywds['function']:
            keywds['function'] = keywds['name']
            keywds['name'] = None
        return keywds
327358
def uncurry(f):
    
    ensure_callable(f)

    result = lambda args=(), kwargs=None: f(*args, **(kwargs or {}))
    functools.update_wrapper(result, f, ('__name__', '__module__'))
    return result
983647
def declassify(to_remove, *args, **kwargs):
    
    def argdecorate(fn):
        """ enable the to_remove argument to the decorator. """
        # wrap the function to get the original docstring
        @wraps(fn)
        def declassed(*args, **kwargs):
            # call the method
            ret = fn(*args, **kwargs)
            # catch errors that are thrown by the api
            try:
                # ensure that ret is a list
                if type(ret) is list:
                    return [r[to_remove] for r in ret]
                return ret[to_remove]
            except KeyError:
                return ret
        return declassed
    return argdecorate
609289
def reset_trace():
    
    global call_dict
    global call_stack
    global func_count
    global func_count_max
    global func_time
    global func_time_max
    global call_stack_timer

    call_dict = {}

    # current call stack
    call_stack = ['__main__']

    # counters for each function
    func_count = {}
    func_count_max = 0

    # accumative time per function
    func_time = {}
    func_time_max = 0

    # keeps track of the start time of each call on the stack
    call_stack_timer = []
350273
def simplify(self):
        
        if self.iscanonical:
            return self

        expr = self.cancel()
        if not isinstance(expr, self.__class__):
            return expr.simplify()

        if expr.args[0] in (self.TRUE, self.FALSE,):
            return expr.args[0].dual

        expr = self.__class__(expr.args[0].simplify())
        expr.iscanonical = True
        return expr
812594
def all_function_definitions(function):
    
    return [function] + [f for c in function.contract.inheritance
                         for f in c.functions_and_modifiers_not_inherited
                         if f.full_name == function.full_name]
805318
def simplify(self, options=None):
        

        simple = {
            "class": type(self).__name__,
            "is_change": self.is_change(),
            "description": self.get_description(),
            "label": self.label,
        }

        if options:
            simple["is_ignored"] = self.is_ignored(options)

        if isinstance(self, Addition):
            simple["is_addition"] = True

        if isinstance(self, Removal):
            simple["is_removal"] = True

        if self.entry:
            simple["entry"] = self.entry

        return simple
1170204
def wrap_function(self, func):
        

        def f(*args, **kwds):
            self.enable_by_count()
            try:
                result = func(*args, **kwds)
            finally:
                self.disable_by_count()
            return result
        return f
1340569
def _Function(self, t):
        
        if t.decorators is not None:
            self._fill("@")
            self._dispatch(t.decorators)
        self._fill("def "+t.name + "(")
        defaults = [None] * (len(t.argnames) - len(t.defaults)) + list(t.defaults)
        for i, arg in enumerate(zip(t.argnames, defaults)):
            self._write(arg[0])
            if arg[1] is not None:
                self._write('=')
                self._dispatch(arg[1])
            if i < len(t.argnames)-1:
                self._write(', ')
        self._write(")")
        if self._single_func:
            self._do_indent = False
        self._enter()
        self._dispatch(t.code)
        self._leave()
        self._do_indent = True
1159730
def replace_cleanup_func(self, func, only_read=False):
        
        self.logger.info('Replace the cleanup function %s ---> %s' % (
            get_function_signature(self.cleanup), get_function_signature(func)))
        self.cleanup = func
        return True
1137178
def visit_FunctionDef(self, node):
        
        # Ensure there are no nested functions.
        assert self.current_function is None
        self.current_function = node
        self.naming = dict()
        self.in_cond = False  # True when we are in a if, while or for
        self.generic_visit(node)
        self.current_function = None
313003
def compose(*funcs):
    
    # slightly optimized for most common cases and hence verbose
    if len(funcs) == 2: f0,f1=funcs; return lambda *a,**kw: f0(f1(*a,**kw))
    elif len(funcs) == 3: f0,f1,f2=funcs; return lambda *a,**kw: f0(f1(f2(*a,**kw)))
    elif len(funcs) == 0: return lambda x:x     # XXX single kwarg
    elif len(funcs) == 1: return funcs[0]
    else:
        def composed(*args,**kwargs):
            y = funcs[-1](*args,**kwargs)
            for f in funcs[:0:-1]: y = f(y)
            return y
        return composed
263727
def declfuncs(self):
    """"""
    for f in self.body:
        if (hasattr(f, '_ctype')
                and isinstance(f._ctype, FuncType)
                and not hasattr(f, 'body')):
            yield f