def METHOD_NAME(
    self,
    tx,
    name,
    args: "List[VariableTracker]",
    kwargs: "Dict[str, VariableTracker]",
) -> "VariableTracker":
    from .tensor import SymNodeVariable
    options = VariableTracker.propagate(self, args, kwargs.values())
    if istype(self.value, tuple):
        # empty tuple constant etc
        return variables.TupleVariable(
            items=self.unpack_var_sequence(tx), source=self.source, **options
        ).METHOD_NAME(tx, name, args, kwargs)
    if istype(self.value, list):
        return variables.ListVariable(
            items=self.unpack_var_sequence(tx), source=self.source, **options
        ).METHOD_NAME(tx, name, args, kwargs)
    if any(isinstance(x, SymNodeVariable) for x in args):
        # Promote to SymNodeVariable for operations involving dynamic shapes.
        return variables.SymNodeVariable(self.as_proxy(), self.value).METHOD_NAME(
            tx, name, args, kwargs
        )
    try:
        const_args = [a.as_python_constant() for a in args]
        const_kwargs = {k: v.as_python_constant() for k, v in kwargs.items()}
    except NotImplementedError:
        return super().METHOD_NAME(tx, name, args, kwargs)
    def has_arith_binop(num_ty):
        return (
            isinstance(self.value, num_ty)
            and hasattr(operator, name)
            and len(args) == 1
            and args[0].is_python_constant()
        )
    if isinstance(self.value, str) and name in str.__dict__.keys():
        method = getattr(self.value, name)
        return ConstantVariable(method(*const_args, **const_kwargs), **options)
    elif has_arith_binop(int) or has_arith_binop(float):
        op = getattr(operator, name)
        add_target = const_args[0]
        if isinstance(add_target, (torch.SymInt, torch.SymFloat)):
            from .tensor import SymNodeVariable
            # Addition between a non sym and sym makes a sym
            # sym_num = tx.output.register_attr_or_module(
            #     add_target, f"sym_shape_{add_target}", source=None
            # )
            proxy = tx.output.create_proxy(
                "call_function", op, (self.value, add_target), {}
            )
            return SymNodeVariable.create(tx, proxy, add_target, **options)
        return ConstantVariable(op(self.value, add_target), **options)
    elif name == "__len__" and not (args or kwargs):
        return ConstantVariable(len(self.value), **options)
    elif name == "__contains__" and len(args) == 1 and args[0].is_python_constant():
        assert not kwargs
        search = args[0].as_python_constant()
        result = search in self.value
        return ConstantVariable(result, **options)
    unimplemented(f"const method call {typestr(self.value)}.{name}")