Return a list of potential signature
        It is a list, as Constant variables can be converted to int256
    Args:
        ir (slithIR.operation)
    Returns:
        list(str)
773937
def get_sig(ir, name):
    '''
        
    '''
    sig = '{}({})'

    # list of list of arguments
    argss = convert_arguments(ir.arguments)
    return [sig.format(name, ','.join(args)) for args in argss]
275474
def attrlist(self):
        ''
        keymap = self.config.get('KEY_MAP')
        if keymap:
            # https://github.com/ContinuumIO/flask-ldap-login/issues/11
            # https://continuumsupport.zendesk.com/agent/tickets/393
            return [s.encode('utf-8') for s in keymap.values()]
        else:
            return None
103918
def Constant(cls, irsb_c, val, ty):
        
        assert not (isinstance(val, VexValue) or isinstance(val, IRExpr))
        rdt = irsb_c.mkconst(val, ty)
        return cls(irsb_c, rdt)
865335
def parse_indexer_signature(sig):
    
    match = IDXR_SIG_RE.match(sig.strip())
    if not match:
        raise RuntimeError('Indexer signature invalid: ' + sig)
    modifiers, return_type, params, getter, setter = match.groups()
    params = split_sig(params)
    params = [parse_param_signature(x) for x in params]
    return (modifiers.split(), return_type, params,
            getter is not None, setter is not None)
203223
def iriref_to_str(self, ref: ShExDocParser.IRIREF) -> str:
        
        rval = ref.getText()[1:-1].encode('utf-8').decode('unicode-escape')
        return rval if ':' in rval or not self.base else self.base.val + rval
787751
def get_signatures_with_results(vcs):
    
    results_dir = os.path.join(vcs.private_dir(), 'results')
    if not os.path.exists(results_dir):
        return []
    rel_paths = os.listdir(results_dir)
    return [p for p in rel_paths if os.path.isdir(os.path.join(results_dir, p))]
155385
def to_list(self):
        
        return [self.i, self.Ω, self.e, self.ω, self.M, self.n]
661972
def spectra(
            self):
        
        specResultsList = []
        specResultsList[:] = [dict(l) for l in self.specResultsList]
        return specResultsList
47740
def get_signature_vars(section):
    ''''''

    # signature vars should contain parameters defined in global section
    # #1155
    signature_vars = set(
        section.parameters.keys()
        & accessed_vars(strip_param_defs(section.global_stmts)))

    input_idx = find_statement(section, 'input')
    after_input_idx = 0 if input_idx is None else input_idx + 1

    for statement in section.statements[after_input_idx:]:
        if statement[0] == '=':
            signature_vars |= accessed_vars('='.join(statement[1:3]))
        elif statement[0] == '!':
            signature_vars |= accessed_vars(statement[1])
    # finally, tasks..
    if section.task:
        signature_vars |= accessed_vars(section.task)

    return {x for x in signature_vars if not x.startswith('__')}
1154838
def list_(runas=None):
    '''
    
    '''
    rubies = []
    output = _rvm(['list'], runas=runas)
    if output:
        regex = re.compile(r'^[= ]([*> ]) ([^- ]+)-([^ ]+) \[ (.*) \]')
        for line in output.splitlines():
            match = regex.match(line)
            if match:
                rubies.append([
                    match.group(2), match.group(3), match.group(1) == '*'
                ])
    return rubies
399605
def strnumlist(prefix: str, numbers: List[int], suffix: str = "") -> List[str]:
    
    return ["{}{}{}".format(prefix, num, suffix) for num in numbers]
1221879
def get_staged_signatures(vcs):
    
    staged_path = _get_staged_history_path(vcs)
    known_signatures = []
    if os.path.exists(staged_path):
        with open(staged_path, 'r') as f:
            known_signatures = f.read().split()
    return known_signatures
1242320
def scope_to_list(scope):
    """"""
    if isinstance(scope, (tuple, list, set)):
        return [unicode_type(s) for s in scope]
    elif scope is None:
        return None
    else:
        return scope.strip().split(" ")
277354
def types(self):
        
        return [x for x in self[self.current_scope].values() if isinstance(x, symbols.TYPE)]
554173
def IdentifiersIndexer(instance):
    
    identifiers = instance.Schema()['Identifiers'].get(instance)
    return [safe_unicode(i['Identifier']) for i in identifiers]
743093
def return_type(self):
        
        returns = self.returns
        if returns:
            return [r.type for r in returns]
        return None
556458
def _get_slicers(self, index):
        
        if not index:  # first item.
            return slice(0, self.SIGNATURE[0])
        if index >= len(self.SIGNATURE):
            raise IndexError('index out of self.SIGNATURE range')
        pad_start = sum(self.SIGNATURE[:index])
        pad_stop = pad_start + self.SIGNATURE[index]
        return slice(pad_start, pad_stop)