python_torch_functions.cpp

// generated from tools/autograd/templates/python_torch_functions.cpp

// Python bindings for torch.* functions implemented through ATen.
//
// The functions are bound as static methods on a class
// torch._C._VariableFunctions which is also aliased as Variable._torch.

#include <Python.h>

#include "torch/csrc/Exceptions.h"
#include "torch/csrc/autograd/python_variable.h"
#include "torch/csrc/autograd/utils/wrap_outputs.h"
#include "torch/csrc/utils/python_arg_parser.h"
#include "torch/csrc/utils/tensor_numpy.h"

#include "python_torch_functions_dispatch.h"

using at::Tensor;
using at::Scalar;
using at::ScalarType;
using at::Backend;
using namespace torch::autograd::utils;

namespace torch { namespace autograd {

static Tensor dispatch_clamp(const Tensor & self, Scalar min, Scalar max) {
  AutoNoGIL no_gil;
  AutoGPU auto_gpu(self);
  return self.clamp(min, max);
}
static Tensor dispatch_clamp_min(const Tensor & self, Scalar min) {
  AutoNoGIL no_gil;
  AutoGPU auto_gpu(self);
  return self.clamp_min(min);
}
static Tensor dispatch_clamp_max(const Tensor & self, Scalar max) {
  AutoNoGIL no_gil;
  AutoGPU auto_gpu(self);
  return self.clamp_max(max);
}

// The Python clamp() syntax has to be mapped to one of three C++ functions
static PyObject * THPVariable_clamp(PyObject* module, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "clamp(Tensor input, Scalar min=None, Scalar max=None)",
  });
  PyObject* parsed_args[4];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (!r.isNone(1) && !r.isNone(2)) {
    return THPVariable_Wrap(dispatch_clamp(r.tensor(0), r.scalar(1), r.scalar(2)));
  } else if (!r.isNone(1)) {
    return THPVariable_Wrap(dispatch_clamp_min(r.tensor(0), r.scalar(1)));
  } else if (!r.isNone(2)) {
    return THPVariable_Wrap(dispatch_clamp_max(r.tensor(0), r.scalar(2)));
  } else {
    throw std::runtime_error("At least one of 'min' or 'max' must not be None");
  }
  END_HANDLE_TH_ERRORS
}

static PyObject * THPVariable_from_numpy(PyObject* module, PyObject* arg)
{
  HANDLE_TH_ERRORS
  auto data = torch::utils::tensor_from_numpy(arg);
  return THPVariable_Wrap(make_variable(std::move(data)));
  END_HANDLE_TH_ERRORS
}

// generated methods start here

static PyObject * THPVariable___and__(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "__and__(Tensor input, Scalar other, *, Tensor out=None)",
    "__and__(Tensor input, Tensor other, *, Tensor out=None)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(2)) {
      return wrap(dispatch___and__(r.tensor(0), r.scalar(1)));
    } else {
      return wrap(dispatch___and__(r.tensor(0), r.scalar(1), r.tensor(2)));
    }
  } else if (r.idx == 1) {
    if (r.isNone(2)) {
      return wrap(dispatch___and__(r.tensor(0), r.tensor(1)));
    } else {
      return wrap(dispatch___and__(r.tensor(0), r.tensor(1), r.tensor(2)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable___iand__(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "__iand__(Tensor input, Scalar other)",
    "__iand__(Tensor input, Tensor other)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch___iand__(r.tensor(0), r.scalar(1)));
  } else if (r.idx == 1) {
    return wrap(dispatch___iand__(r.tensor(0), r.tensor(1)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable___ilshift__(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "__ilshift__(Tensor input, Scalar other)",
    "__ilshift__(Tensor input, Tensor other)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch___ilshift__(r.tensor(0), r.scalar(1)));
  } else if (r.idx == 1) {
    return wrap(dispatch___ilshift__(r.tensor(0), r.tensor(1)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable___ior__(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "__ior__(Tensor input, Scalar other)",
    "__ior__(Tensor input, Tensor other)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch___ior__(r.tensor(0), r.scalar(1)));
  } else if (r.idx == 1) {
    return wrap(dispatch___ior__(r.tensor(0), r.tensor(1)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable___irshift__(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "__irshift__(Tensor input, Scalar other)",
    "__irshift__(Tensor input, Tensor other)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch___irshift__(r.tensor(0), r.scalar(1)));
  } else if (r.idx == 1) {
    return wrap(dispatch___irshift__(r.tensor(0), r.tensor(1)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable___ixor__(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "__ixor__(Tensor input, Scalar other)",
    "__ixor__(Tensor input, Tensor other)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch___ixor__(r.tensor(0), r.scalar(1)));
  } else if (r.idx == 1) {
    return wrap(dispatch___ixor__(r.tensor(0), r.tensor(1)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable___lshift__(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "__lshift__(Tensor input, Scalar other, *, Tensor out=None)",
    "__lshift__(Tensor input, Tensor other, *, Tensor out=None)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(2)) {
      return wrap(dispatch___lshift__(r.tensor(0), r.scalar(1)));
    } else {
      return wrap(dispatch___lshift__(r.tensor(0), r.scalar(1), r.tensor(2)));
    }
  } else if (r.idx == 1) {
    if (r.isNone(2)) {
      return wrap(dispatch___lshift__(r.tensor(0), r.tensor(1)));
    } else {
      return wrap(dispatch___lshift__(r.tensor(0), r.tensor(1), r.tensor(2)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable___or__(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "__or__(Tensor input, Scalar other, *, Tensor out=None)",
    "__or__(Tensor input, Tensor other, *, Tensor out=None)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(2)) {
      return wrap(dispatch___or__(r.tensor(0), r.scalar(1)));
    } else {
      return wrap(dispatch___or__(r.tensor(0), r.scalar(1), r.tensor(2)));
    }
  } else if (r.idx == 1) {
    if (r.isNone(2)) {
      return wrap(dispatch___or__(r.tensor(0), r.tensor(1)));
    } else {
      return wrap(dispatch___or__(r.tensor(0), r.tensor(1), r.tensor(2)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable___rshift__(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "__rshift__(Tensor input, Scalar other, *, Tensor out=None)",
    "__rshift__(Tensor input, Tensor other, *, Tensor out=None)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(2)) {
      return wrap(dispatch___rshift__(r.tensor(0), r.scalar(1)));
    } else {
      return wrap(dispatch___rshift__(r.tensor(0), r.scalar(1), r.tensor(2)));
    }
  } else if (r.idx == 1) {
    if (r.isNone(2)) {
      return wrap(dispatch___rshift__(r.tensor(0), r.tensor(1)));
    } else {
      return wrap(dispatch___rshift__(r.tensor(0), r.tensor(1), r.tensor(2)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable___xor__(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "__xor__(Tensor input, Scalar other, *, Tensor out=None)",
    "__xor__(Tensor input, Tensor other, *, Tensor out=None)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(2)) {
      return wrap(dispatch___xor__(r.tensor(0), r.scalar(1)));
    } else {
      return wrap(dispatch___xor__(r.tensor(0), r.scalar(1), r.tensor(2)));
    }
  } else if (r.idx == 1) {
    if (r.isNone(2)) {
      return wrap(dispatch___xor__(r.tensor(0), r.tensor(1)));
    } else {
      return wrap(dispatch___xor__(r.tensor(0), r.tensor(1), r.tensor(2)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable__convolution(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "_convolution(Tensor input, Tensor weight, Tensor? bias, IntList stride, IntList padding, IntList dilation, bool transposed, IntList output_padding, int64_t groups, bool benchmark, bool deterministic, bool cudnn_enabled)",
  });

  PyObject* parsed_args[12];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch__convolution(r.tensor(0), r.tensor(1), r.tensor(2), r.intlist(3), r.intlist(4), r.intlist(5), r.toBool(6), r.intlist(7), r.toInt64(8), r.toBool(9), r.toBool(10), r.toBool(11)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable__convolution_nogroup(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "_convolution_nogroup(Tensor input, Tensor weight, Tensor? bias, IntList stride, IntList padding, IntList dilation, bool transposed, IntList output_padding)",
  });

  PyObject* parsed_args[8];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch__convolution_nogroup(r.tensor(0), r.tensor(1), r.tensor(2), r.intlist(3), r.intlist(4), r.intlist(5), r.toBool(6), r.intlist(7)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable__copy_ignoring_overlaps_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "_copy_ignoring_overlaps_(Tensor input, Tensor src)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch__copy_ignoring_overlaps_(r.tensor(0), r.tensor(1)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable__det_with_svd(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "_det_with_svd(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch__det_with_svd(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable__indices(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "_indices(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch__indices(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable__s_where(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "_s_where(Tensor condition, Tensor input, Tensor other)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch__s_where(r.tensor(0), r.tensor(1), r.tensor(2)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable__sparse_mask(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "_sparse_mask(Tensor input, Tensor mask)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch__sparse_mask(r.tensor(0), SparseTensor(r.tensor(1))));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable__standard_gamma(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "_standard_gamma(Tensor input, *, Generator generator=None, Tensor out=None)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(2)) {
      return wrap(dispatch__standard_gamma(r.tensor(0), r.generator(1)));
    } else {
      return wrap(dispatch__standard_gamma(r.tensor(0), r.generator(1), r.tensor(2)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable__standard_gamma_grad(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "_standard_gamma_grad(Tensor input, Tensor output)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch__standard_gamma_grad(r.tensor(0), r.tensor(1)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable__values(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "_values(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch__values(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_abs(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "abs(Tensor input, *, Tensor out=None)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(1)) {
      return wrap(dispatch_abs(r.tensor(0)));
    } else {
      return wrap(dispatch_abs(r.tensor(0), r.tensor(1)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_abs_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "abs_(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_abs_(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_acos(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "acos(Tensor input, *, Tensor out=None)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(1)) {
      return wrap(dispatch_acos(r.tensor(0)));
    } else {
      return wrap(dispatch_acos(r.tensor(0), r.tensor(1)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_acos_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "acos_(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_acos_(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_adaptive_avg_pool1d(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "adaptive_avg_pool1d(Tensor input, IntList[1] output_size)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_adaptive_avg_pool1d(r.tensor(0), r.intlist(1)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_adaptive_max_pool1d(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "adaptive_max_pool1d(Tensor input, IntList[1] output_size)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_adaptive_max_pool1d(r.tensor(0), r.intlist(1)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_add(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "add(Tensor input, Scalar alpha, Tensor other)|deprecated",
    "add(Tensor input, Scalar other, *, Scalar alpha=1, Tensor out=None)",
    "add(Tensor input, Tensor other, *, Scalar alpha=1, Tensor out=None)",
  });

  PyObject* parsed_args[4];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_add(r.tensor(0), r.scalar(1), r.tensor(2)));
  } else if (r.idx == 1) {
    if (r.isNone(3)) {
      return wrap(dispatch_add(r.tensor(0), r.scalar(1), r.scalar(2)));
    } else {
      return wrap(dispatch_add(r.tensor(0), r.scalar(1), r.scalar(2), r.tensor(3)));
    }
  } else if (r.idx == 2) {
    if (r.isNone(3)) {
      return wrap(dispatch_add(r.tensor(0), r.tensor(1), r.scalar(2)));
    } else {
      return wrap(dispatch_add(r.tensor(0), r.tensor(1), r.scalar(2), r.tensor(3)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_add_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "add_(Tensor input, Scalar alpha, Tensor other)|deprecated",
    "add_(Tensor input, Scalar other, *, Scalar alpha=1)",
    "add_(Tensor input, Tensor other, *, Scalar alpha=1)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_add_(r.tensor(0), r.scalar(1), r.tensor(2)));
  } else if (r.idx == 1) {
    return wrap(dispatch_add_(r.tensor(0), r.scalar(1), r.scalar(2)));
  } else if (r.idx == 2) {
    return wrap(dispatch_add_(r.tensor(0), r.tensor(1), r.scalar(2)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_addbmm(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "addbmm(Scalar beta, Tensor input, Scalar alpha, Tensor batch1, Tensor batch2)|deprecated",
    "addbmm(Scalar beta, Tensor input, Tensor batch1, Tensor batch2)|deprecated",
    "addbmm(Tensor input, Tensor batch1, Tensor batch2, *, Scalar beta=1, Scalar alpha=1, Tensor out=None)",
  });

  PyObject* parsed_args[6];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_addbmm(r.scalar(0), r.tensor(1), r.scalar(2), r.tensor(3), r.tensor(4)));
  } else if (r.idx == 1) {
    return wrap(dispatch_addbmm(r.scalar(0), r.tensor(1), r.tensor(2), r.tensor(3)));
  } else if (r.idx == 2) {
    if (r.isNone(5)) {
      return wrap(dispatch_addbmm(r.tensor(0), r.tensor(1), r.tensor(2), r.scalar(3), r.scalar(4)));
    } else {
      return wrap(dispatch_addbmm(r.tensor(0), r.tensor(1), r.tensor(2), r.scalar(3), r.scalar(4), r.tensor(5)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_addbmm_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "addbmm_(Scalar beta, Tensor input, Scalar alpha, Tensor batch1, Tensor batch2)|deprecated",
    "addbmm_(Scalar beta, Tensor input, Tensor batch1, Tensor batch2)|deprecated",
    "addbmm_(Tensor input, Tensor batch1, Tensor batch2, *, Scalar beta=1, Scalar alpha=1)",
  });

  PyObject* parsed_args[5];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_addbmm_(r.scalar(0), r.tensor(1), r.scalar(2), r.tensor(3), r.tensor(4)));
  } else if (r.idx == 1) {
    return wrap(dispatch_addbmm_(r.scalar(0), r.tensor(1), r.tensor(2), r.tensor(3)));
  } else if (r.idx == 2) {
    return wrap(dispatch_addbmm_(r.tensor(0), r.tensor(1), r.tensor(2), r.scalar(3), r.scalar(4)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_addcdiv(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "addcdiv(Tensor input, Scalar value, Tensor tensor1, Tensor tensor2)|deprecated",
    "addcdiv(Tensor input, Tensor tensor1, Tensor tensor2, *, Scalar value=1, Tensor out=None)",
  });

  PyObject* parsed_args[5];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_addcdiv(r.tensor(0), r.scalar(1), r.tensor(2), r.tensor(3)));
  } else if (r.idx == 1) {
    if (r.isNone(4)) {
      return wrap(dispatch_addcdiv(r.tensor(0), r.tensor(1), r.tensor(2), r.scalar(3)));
    } else {
      return wrap(dispatch_addcdiv(r.tensor(0), r.tensor(1), r.tensor(2), r.scalar(3), r.tensor(4)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_addcdiv_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "addcdiv_(Tensor input, Scalar value, Tensor tensor1, Tensor tensor2)|deprecated",
    "addcdiv_(Tensor input, Tensor tensor1, Tensor tensor2, *, Scalar value=1)",
  });

  PyObject* parsed_args[4];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_addcdiv_(r.tensor(0), r.scalar(1), r.tensor(2), r.tensor(3)));
  } else if (r.idx == 1) {
    return wrap(dispatch_addcdiv_(r.tensor(0), r.tensor(1), r.tensor(2), r.scalar(3)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_addcmul(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "addcmul(Tensor input, Scalar value, Tensor tensor1, Tensor tensor2)|deprecated",
    "addcmul(Tensor input, Tensor tensor1, Tensor tensor2, *, Scalar value=1, Tensor out=None)",
  });

  PyObject* parsed_args[5];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_addcmul(r.tensor(0), r.scalar(1), r.tensor(2), r.tensor(3)));
  } else if (r.idx == 1) {
    if (r.isNone(4)) {
      return wrap(dispatch_addcmul(r.tensor(0), r.tensor(1), r.tensor(2), r.scalar(3)));
    } else {
      return wrap(dispatch_addcmul(r.tensor(0), r.tensor(1), r.tensor(2), r.scalar(3), r.tensor(4)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_addcmul_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "addcmul_(Tensor input, Scalar value, Tensor tensor1, Tensor tensor2)|deprecated",
    "addcmul_(Tensor input, Tensor tensor1, Tensor tensor2, *, Scalar value=1)",
  });

  PyObject* parsed_args[4];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_addcmul_(r.tensor(0), r.scalar(1), r.tensor(2), r.tensor(3)));
  } else if (r.idx == 1) {
    return wrap(dispatch_addcmul_(r.tensor(0), r.tensor(1), r.tensor(2), r.scalar(3)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_addmm(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "addmm(Scalar beta, Tensor input, Scalar alpha, Tensor mat1, Tensor mat2)|deprecated",
    "addmm(Scalar beta, Tensor input, Tensor mat1, Tensor mat2)|deprecated",
    "addmm(Tensor input, Tensor mat1, Tensor mat2, *, Scalar beta=1, Scalar alpha=1, Tensor out=None)",
  });

  PyObject* parsed_args[6];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_addmm(r.scalar(0), r.tensor(1), r.scalar(2), r.tensor(3), r.tensor(4)));
  } else if (r.idx == 1) {
    return wrap(dispatch_addmm(r.scalar(0), r.tensor(1), r.tensor(2), r.tensor(3)));
  } else if (r.idx == 2) {
    if (r.isNone(5)) {
      return wrap(dispatch_addmm(r.tensor(0), r.tensor(1), r.tensor(2), r.scalar(3), r.scalar(4)));
    } else {
      return wrap(dispatch_addmm(r.tensor(0), r.tensor(1), r.tensor(2), r.scalar(3), r.scalar(4), r.tensor(5)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_addmm_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "addmm_(Scalar beta, Tensor input, Scalar alpha, Tensor mat1, Tensor mat2)|deprecated",
    "addmm_(Scalar beta, Tensor input, Tensor mat1, Tensor mat2)|deprecated",
    "addmm_(Tensor input, Tensor mat1, Tensor mat2, *, Scalar beta=1, Scalar alpha=1)",
  });

  PyObject* parsed_args[5];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_addmm_(r.scalar(0), r.tensor(1), r.scalar(2), r.tensor(3), r.tensor(4)));
  } else if (r.idx == 1) {
    return wrap(dispatch_addmm_(r.scalar(0), r.tensor(1), r.tensor(2), r.tensor(3)));
  } else if (r.idx == 2) {
    return wrap(dispatch_addmm_(r.tensor(0), r.tensor(1), r.tensor(2), r.scalar(3), r.scalar(4)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_addmv(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "addmv(Scalar beta, Tensor input, Scalar alpha, Tensor mat, Tensor vec)|deprecated",
    "addmv(Scalar beta, Tensor input, Tensor mat, Tensor vec)|deprecated",
    "addmv(Tensor input, Tensor mat, Tensor vec, *, Scalar beta=1, Scalar alpha=1, Tensor out=None)",
  });

  PyObject* parsed_args[6];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_addmv(r.scalar(0), r.tensor(1), r.scalar(2), r.tensor(3), r.tensor(4)));
  } else if (r.idx == 1) {
    return wrap(dispatch_addmv(r.scalar(0), r.tensor(1), r.tensor(2), r.tensor(3)));
  } else if (r.idx == 2) {
    if (r.isNone(5)) {
      return wrap(dispatch_addmv(r.tensor(0), r.tensor(1), r.tensor(2), r.scalar(3), r.scalar(4)));
    } else {
      return wrap(dispatch_addmv(r.tensor(0), r.tensor(1), r.tensor(2), r.scalar(3), r.scalar(4), r.tensor(5)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_addmv_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "addmv_(Scalar beta, Tensor input, Scalar alpha, Tensor mat, Tensor vec)|deprecated",
    "addmv_(Scalar beta, Tensor input, Tensor mat, Tensor vec)|deprecated",
    "addmv_(Tensor input, Tensor mat, Tensor vec, *, Scalar beta=1, Scalar alpha=1)",
  });

  PyObject* parsed_args[5];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_addmv_(r.scalar(0), r.tensor(1), r.scalar(2), r.tensor(3), r.tensor(4)));
  } else if (r.idx == 1) {
    return wrap(dispatch_addmv_(r.scalar(0), r.tensor(1), r.tensor(2), r.tensor(3)));
  } else if (r.idx == 2) {
    return wrap(dispatch_addmv_(r.tensor(0), r.tensor(1), r.tensor(2), r.scalar(3), r.scalar(4)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_addr(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "addr(Scalar beta, Tensor input, Scalar alpha, Tensor vec1, Tensor vec2)|deprecated",
    "addr(Scalar beta, Tensor input, Tensor vec1, Tensor vec2)|deprecated",
    "addr(Tensor input, Tensor vec1, Tensor vec2, *, Scalar beta=1, Scalar alpha=1, Tensor out=None)",
  });

  PyObject* parsed_args[6];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_addr(r.scalar(0), r.tensor(1), r.scalar(2), r.tensor(3), r.tensor(4)));
  } else if (r.idx == 1) {
    return wrap(dispatch_addr(r.scalar(0), r.tensor(1), r.tensor(2), r.tensor(3)));
  } else if (r.idx == 2) {
    if (r.isNone(5)) {
      return wrap(dispatch_addr(r.tensor(0), r.tensor(1), r.tensor(2), r.scalar(3), r.scalar(4)));
    } else {
      return wrap(dispatch_addr(r.tensor(0), r.tensor(1), r.tensor(2), r.scalar(3), r.scalar(4), r.tensor(5)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_addr_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "addr_(Scalar beta, Tensor input, Scalar alpha, Tensor vec1, Tensor vec2)|deprecated",
    "addr_(Scalar beta, Tensor input, Tensor vec1, Tensor vec2)|deprecated",
    "addr_(Tensor input, Tensor vec1, Tensor vec2, *, Scalar beta=1, Scalar alpha=1)",
  });

  PyObject* parsed_args[5];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_addr_(r.scalar(0), r.tensor(1), r.scalar(2), r.tensor(3), r.tensor(4)));
  } else if (r.idx == 1) {
    return wrap(dispatch_addr_(r.scalar(0), r.tensor(1), r.tensor(2), r.tensor(3)));
  } else if (r.idx == 2) {
    return wrap(dispatch_addr_(r.tensor(0), r.tensor(1), r.tensor(2), r.scalar(3), r.scalar(4)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_all(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "all(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_all(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_allclose(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "allclose(Tensor input, Tensor other, double rtol=1e-05, double atol=1e-08)",
  });

  PyObject* parsed_args[4];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_allclose(r.tensor(0), r.tensor(1), r.toDouble(2), r.toDouble(3)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_any(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "any(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_any(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_arange(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "arange(Scalar end, *, Tensor out=None)",
    "arange(Scalar start, Scalar end, Scalar step=1, *, Tensor out=None)",
  });

  PyObject* parsed_args[4];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(1)) {
      return wrap(dispatch_arange(r.scalar(0)));
    } else {
      return wrap(dispatch_arange(r.scalar(0), r.tensor(1)));
    }
  } else if (r.idx == 1) {
    if (r.isNone(3)) {
      return wrap(dispatch_arange(r.scalar(0), r.scalar(1), r.scalar(2)));
    } else {
      return wrap(dispatch_arange(r.scalar(0), r.scalar(1), r.scalar(2), r.tensor(3)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_as_strided(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "as_strided(Tensor input, IntList size, IntList stride, int64_t storage_offset=-1, *, Tensor out=None)",
  });

  PyObject* parsed_args[5];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(4)) {
      return wrap(dispatch_as_strided(r.tensor(0), r.intlist(1), r.intlist(2), r.toInt64(3)));
    } else {
      return wrap(dispatch_as_strided(r.tensor(0), r.intlist(1), r.intlist(2), r.toInt64(3), r.tensor(4)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_as_strided_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "as_strided_(Tensor input, IntList size, IntList stride, int64_t storage_offset=-1)",
  });

  PyObject* parsed_args[4];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_as_strided_(r.tensor(0), r.intlist(1), r.intlist(2), r.toInt64(3)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_asin(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "asin(Tensor input, *, Tensor out=None)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(1)) {
      return wrap(dispatch_asin(r.tensor(0)));
    } else {
      return wrap(dispatch_asin(r.tensor(0), r.tensor(1)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_asin_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "asin_(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_asin_(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_atan(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "atan(Tensor input, *, Tensor out=None)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(1)) {
      return wrap(dispatch_atan(r.tensor(0)));
    } else {
      return wrap(dispatch_atan(r.tensor(0), r.tensor(1)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_atan2(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "atan2(Tensor input, Tensor other, *, Tensor out=None)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(2)) {
      return wrap(dispatch_atan2(r.tensor(0), r.tensor(1)));
    } else {
      return wrap(dispatch_atan2(r.tensor(0), r.tensor(1), r.tensor(2)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_atan2_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "atan2_(Tensor input, Tensor other)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_atan2_(r.tensor(0), r.tensor(1)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_atan_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "atan_(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_atan_(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_baddbmm(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "baddbmm(Scalar beta, Tensor input, Scalar alpha, Tensor batch1, Tensor batch2)|deprecated",
    "baddbmm(Scalar beta, Tensor input, Tensor batch1, Tensor batch2)|deprecated",
    "baddbmm(Tensor input, Tensor batch1, Tensor batch2, *, Scalar beta=1, Scalar alpha=1, Tensor out=None)",
  });

  PyObject* parsed_args[6];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_baddbmm(r.scalar(0), r.tensor(1), r.scalar(2), r.tensor(3), r.tensor(4)));
  } else if (r.idx == 1) {
    return wrap(dispatch_baddbmm(r.scalar(0), r.tensor(1), r.tensor(2), r.tensor(3)));
  } else if (r.idx == 2) {
    if (r.isNone(5)) {
      return wrap(dispatch_baddbmm(r.tensor(0), r.tensor(1), r.tensor(2), r.scalar(3), r.scalar(4)));
    } else {
      return wrap(dispatch_baddbmm(r.tensor(0), r.tensor(1), r.tensor(2), r.scalar(3), r.scalar(4), r.tensor(5)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_baddbmm_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "baddbmm_(Scalar beta, Tensor input, Scalar alpha, Tensor batch1, Tensor batch2)|deprecated",
    "baddbmm_(Scalar beta, Tensor input, Tensor batch1, Tensor batch2)|deprecated",
    "baddbmm_(Tensor input, Tensor batch1, Tensor batch2, *, Scalar beta=1, Scalar alpha=1)",
  });

  PyObject* parsed_args[5];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_baddbmm_(r.scalar(0), r.tensor(1), r.scalar(2), r.tensor(3), r.tensor(4)));
  } else if (r.idx == 1) {
    return wrap(dispatch_baddbmm_(r.scalar(0), r.tensor(1), r.tensor(2), r.tensor(3)));
  } else if (r.idx == 2) {
    return wrap(dispatch_baddbmm_(r.tensor(0), r.tensor(1), r.tensor(2), r.scalar(3), r.scalar(4)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_batch_norm(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "batch_norm(Tensor input, Tensor? weight, Tensor? bias, Tensor running_mean, Tensor running_var, bool training, double momentum, double eps, bool cudnn_enabled)",
  });

  PyObject* parsed_args[9];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_batch_norm(r.tensor(0), r.tensor(1), r.tensor(2), r.tensor(3), r.tensor(4), r.toBool(5), r.toDouble(6), r.toDouble(7), r.toBool(8)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_bernoulli(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "bernoulli(Tensor input, *, Generator generator=None, Tensor out=None)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(2)) {
      return wrap(dispatch_bernoulli(r.tensor(0), r.generator(1)));
    } else {
      return wrap(dispatch_bernoulli(r.tensor(0), r.generator(1), r.tensor(2)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_bernoulli_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "bernoulli_(Tensor input, Tensor p, Generator generator=None)",
    "bernoulli_(Tensor input, double p, Generator generator=None)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_bernoulli_(r.tensor(0), r.tensor(1), r.generator(2)));
  } else if (r.idx == 1) {
    return wrap(dispatch_bernoulli_(r.tensor(0), r.toDouble(1), r.generator(2)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_bmm(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "bmm(Tensor input, Tensor mat2, *, Tensor out=None)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(2)) {
      return wrap(dispatch_bmm(r.tensor(0), r.tensor(1)));
    } else {
      return wrap(dispatch_bmm(r.tensor(0), r.tensor(1), r.tensor(2)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_btrifact(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "btrifact(Tensor input, *, bool pivot=True, TensorList[2] out=None)",
  });

  PyObject* parsed_args[4];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(2)) {
      return wrap(dispatch_btrifact(r.tensor(0), r.toBool(1)));
    } else {
      auto results = r.tensorlist_n<2>(2);
      return wrap(dispatch_btrifact(r.tensor(0), r.toBool(1), results[0], results[1]));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_btrifact_with_info(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "btrifact_with_info(Tensor input, *, bool pivot=True, TensorList[3] out=None)",
  });

  PyObject* parsed_args[5];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(2)) {
      return wrap(dispatch_btrifact_with_info(r.tensor(0), r.toBool(1)));
    } else {
      auto results = r.tensorlist_n<3>(2);
      return wrap(dispatch_btrifact_with_info(r.tensor(0), r.toBool(1), results[0], results[1], results[2]));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_btrisolve(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "btrisolve(Tensor input, Tensor LU_data, Tensor LU_pivots, *, Tensor out=None)",
  });

  PyObject* parsed_args[4];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(3)) {
      return wrap(dispatch_btrisolve(r.tensor(0), r.tensor(1), r.tensor(2)));
    } else {
      return wrap(dispatch_btrisolve(r.tensor(0), r.tensor(1), r.tensor(2), r.tensor(3)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_cat(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "cat(TensorList tensors, int64_t dim=0, *, Tensor out=None)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(2)) {
      return wrap(dispatch_cat(r.tensorlist(0), r.toInt64(1)));
    } else {
      return wrap(dispatch_cat(r.tensorlist(0), r.toInt64(1), r.tensor(2)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_cauchy_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "cauchy_(Tensor input, double median=0, double sigma=1, *, Generator generator=None)",
  });

  PyObject* parsed_args[4];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_cauchy_(r.tensor(0), r.toDouble(1), r.toDouble(2), r.generator(3)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_ceil(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "ceil(Tensor input, *, Tensor out=None)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(1)) {
      return wrap(dispatch_ceil(r.tensor(0)));
    } else {
      return wrap(dispatch_ceil(r.tensor(0), r.tensor(1)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_ceil_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "ceil_(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_ceil_(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_chunk(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "chunk(Tensor input, int64_t chunks, int64_t dim=0)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_chunk(r.tensor(0), r.toInt64(1), r.toInt64(2)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_clone(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "clone(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_clone(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_conv1d(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "conv1d(Tensor input, Tensor weight, Tensor bias=None, IntList[1] stride=1, IntList[1] padding=0, IntList[1] dilation=1, int64_t groups=1)",
  });

  PyObject* parsed_args[7];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_conv1d(r.tensor(0), r.tensor(1), r.tensor(2), r.intlist(3), r.intlist(4), r.intlist(5), r.toInt64(6)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_conv2d(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "conv2d(Tensor input, Tensor weight, Tensor bias=None, IntList[2] stride=1, IntList[2] padding=0, IntList[2] dilation=1, int64_t groups=1)",
  });

  PyObject* parsed_args[7];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_conv2d(r.tensor(0), r.tensor(1), r.tensor(2), r.intlist(3), r.intlist(4), r.intlist(5), r.toInt64(6)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_conv3d(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "conv3d(Tensor input, Tensor weight, Tensor bias=None, IntList[3] stride=1, IntList[3] padding=0, IntList[3] dilation=1, int64_t groups=1)",
  });

  PyObject* parsed_args[7];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_conv3d(r.tensor(0), r.tensor(1), r.tensor(2), r.intlist(3), r.intlist(4), r.intlist(5), r.toInt64(6)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_conv_tbc(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "conv_tbc(Tensor input, Tensor weight, Tensor bias, int64_t pad)",
  });

  PyObject* parsed_args[4];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_conv_tbc(r.tensor(0), r.tensor(1), r.tensor(2), r.toInt64(3)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_conv_transpose1d(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "conv_transpose1d(Tensor input, Tensor weight, Tensor bias=None, IntList[1] stride=1, IntList[1] padding=0, IntList[1] output_padding=0, int64_t groups=1, IntList[1] dilation=1)",
  });

  PyObject* parsed_args[8];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_conv_transpose1d(r.tensor(0), r.tensor(1), r.tensor(2), r.intlist(3), r.intlist(4), r.intlist(5), r.toInt64(6), r.intlist(7)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_conv_transpose2d(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "conv_transpose2d(Tensor input, Tensor weight, Tensor bias=None, IntList[2] stride=1, IntList[2] padding=0, IntList[2] output_padding=0, int64_t groups=1, IntList[2] dilation=1)",
  });

  PyObject* parsed_args[8];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_conv_transpose2d(r.tensor(0), r.tensor(1), r.tensor(2), r.intlist(3), r.intlist(4), r.intlist(5), r.toInt64(6), r.intlist(7)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_conv_transpose3d(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "conv_transpose3d(Tensor input, Tensor weight, Tensor bias=None, IntList[3] stride=1, IntList[3] padding=0, IntList[3] output_padding=0, int64_t groups=1, IntList[3] dilation=1)",
  });

  PyObject* parsed_args[8];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_conv_transpose3d(r.tensor(0), r.tensor(1), r.tensor(2), r.intlist(3), r.intlist(4), r.intlist(5), r.toInt64(6), r.intlist(7)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_convolution(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "convolution(Tensor input, Tensor weight, Tensor? bias, IntList stride, IntList padding, IntList dilation, bool transposed, IntList output_padding, int64_t groups)",
  });

  PyObject* parsed_args[9];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_convolution(r.tensor(0), r.tensor(1), r.tensor(2), r.intlist(3), r.intlist(4), r.intlist(5), r.toBool(6), r.intlist(7), r.toInt64(8)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_cos(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "cos(Tensor input, *, Tensor out=None)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(1)) {
      return wrap(dispatch_cos(r.tensor(0)));
    } else {
      return wrap(dispatch_cos(r.tensor(0), r.tensor(1)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_cos_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "cos_(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_cos_(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_cosh(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "cosh(Tensor input, *, Tensor out=None)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(1)) {
      return wrap(dispatch_cosh(r.tensor(0)));
    } else {
      return wrap(dispatch_cosh(r.tensor(0), r.tensor(1)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_cosh_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "cosh_(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_cosh_(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_cross(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "cross(Tensor input, Tensor other, int64_t dim=-1, *, Tensor out=None)",
  });

  PyObject* parsed_args[4];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(3)) {
      return wrap(dispatch_cross(r.tensor(0), r.tensor(1), r.toInt64(2)));
    } else {
      return wrap(dispatch_cross(r.tensor(0), r.tensor(1), r.toInt64(2), r.tensor(3)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_cudnn_affine_grid_generator(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "cudnn_affine_grid_generator(Tensor theta, int64_t N, int64_t C, int64_t H, int64_t W)",
  });

  PyObject* parsed_args[5];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_cudnn_affine_grid_generator(r.tensor(0), r.toInt64(1), r.toInt64(2), r.toInt64(3), r.toInt64(4)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_cudnn_batch_norm(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "cudnn_batch_norm(Tensor input, Tensor weight, Tensor? bias, Tensor running_mean, Tensor running_var, bool training, double exponential_average_factor, double epsilon)",
  });

  PyObject* parsed_args[8];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_cudnn_batch_norm(r.tensor(0), r.tensor(1), r.tensor(2), r.tensor(3), r.tensor(4), r.toBool(5), r.toDouble(6), r.toDouble(7)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_cudnn_convolution(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "cudnn_convolution(Tensor input, Tensor weight, Tensor? bias, IntList padding, IntList stride, IntList dilation, int64_t groups, bool benchmark, bool deterministic)",
  });

  PyObject* parsed_args[9];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_cudnn_convolution(r.tensor(0), r.tensor(1), r.tensor(2), r.intlist(3), r.intlist(4), r.intlist(5), r.toInt64(6), r.toBool(7), r.toBool(8)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_cudnn_convolution_backward_bias(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "cudnn_convolution_backward_bias(Tensor grad_output)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_cudnn_convolution_backward_bias(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_cudnn_convolution_backward_input(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "cudnn_convolution_backward_input(IntList self_size, Tensor grad_output, Tensor weight, IntList padding, IntList stride, IntList dilation, int64_t groups, bool benchmark, bool deterministic)",
  });

  PyObject* parsed_args[9];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_cudnn_convolution_backward_input(r.intlist(0), r.tensor(1), r.tensor(2), r.intlist(3), r.intlist(4), r.intlist(5), r.toInt64(6), r.toBool(7), r.toBool(8)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_cudnn_convolution_backward_weight(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "cudnn_convolution_backward_weight(IntList weight_size, Tensor grad_output, Tensor input, IntList padding, IntList stride, IntList dilation, int64_t groups, bool benchmark, bool deterministic)",
  });

  PyObject* parsed_args[9];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_cudnn_convolution_backward_weight(r.intlist(0), r.tensor(1), r.tensor(2), r.intlist(3), r.intlist(4), r.intlist(5), r.toInt64(6), r.toBool(7), r.toBool(8)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_cudnn_convolution_transpose(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "cudnn_convolution_transpose(Tensor input, Tensor weight, Tensor? bias, IntList padding, IntList output_padding, IntList stride, IntList dilation, int64_t groups, bool benchmark, bool deterministic)",
  });

  PyObject* parsed_args[10];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_cudnn_convolution_transpose(r.tensor(0), r.tensor(1), r.tensor(2), r.intlist(3), r.intlist(4), r.intlist(5), r.intlist(6), r.toInt64(7), r.toBool(8), r.toBool(9)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_cudnn_convolution_transpose_backward_bias(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "cudnn_convolution_transpose_backward_bias(Tensor grad_output)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_cudnn_convolution_transpose_backward_bias(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_cudnn_convolution_transpose_backward_input(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "cudnn_convolution_transpose_backward_input(Tensor grad_output, Tensor weight, IntList padding, IntList stride, IntList dilation, int64_t groups, bool benchmark, bool deterministic)",
  });

  PyObject* parsed_args[8];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_cudnn_convolution_transpose_backward_input(r.tensor(0), r.tensor(1), r.intlist(2), r.intlist(3), r.intlist(4), r.toInt64(5), r.toBool(6), r.toBool(7)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_cudnn_convolution_transpose_backward_weight(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "cudnn_convolution_transpose_backward_weight(IntList weight_size, Tensor grad_output, Tensor input, IntList padding, IntList stride, IntList dilation, int64_t groups, bool benchmark, bool deterministic)",
  });

  PyObject* parsed_args[9];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_cudnn_convolution_transpose_backward_weight(r.intlist(0), r.tensor(1), r.tensor(2), r.intlist(3), r.intlist(4), r.intlist(5), r.toInt64(6), r.toBool(7), r.toBool(8)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_cudnn_grid_sampler(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "cudnn_grid_sampler(Tensor input, Tensor grid)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_cudnn_grid_sampler(r.tensor(0), r.tensor(1)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_cumprod(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "cumprod(Tensor input, int64_t dim, *, Tensor out=None)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(2)) {
      return wrap(dispatch_cumprod(r.tensor(0), r.toInt64(1)));
    } else {
      return wrap(dispatch_cumprod(r.tensor(0), r.toInt64(1), r.tensor(2)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_cumsum(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "cumsum(Tensor input, int64_t dim, *, Tensor out=None)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(2)) {
      return wrap(dispatch_cumsum(r.tensor(0), r.toInt64(1)));
    } else {
      return wrap(dispatch_cumsum(r.tensor(0), r.toInt64(1), r.tensor(2)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_data_ptr(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "data_ptr(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_data_ptr(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_det(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "det(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_det(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_diag(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "diag(Tensor input, int64_t diagonal=0, *, Tensor out=None)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(2)) {
      return wrap(dispatch_diag(r.tensor(0), r.toInt64(1)));
    } else {
      return wrap(dispatch_diag(r.tensor(0), r.toInt64(1), r.tensor(2)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_digamma(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "digamma(Tensor input, *, Tensor out=None)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(1)) {
      return wrap(dispatch_digamma(r.tensor(0)));
    } else {
      return wrap(dispatch_digamma(r.tensor(0), r.tensor(1)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_digamma_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "digamma_(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_digamma_(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_dist(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "dist(Tensor input, Tensor other, Scalar p=2)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_dist(r.tensor(0), r.tensor(1), r.scalar(2)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_div(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "div(Tensor input, Scalar other, *, Tensor out=None)",
    "div(Tensor input, Tensor other, *, Tensor out=None)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(2)) {
      return wrap(dispatch_div(r.tensor(0), r.scalar(1)));
    } else {
      return wrap(dispatch_div(r.tensor(0), r.scalar(1), r.tensor(2)));
    }
  } else if (r.idx == 1) {
    if (r.isNone(2)) {
      return wrap(dispatch_div(r.tensor(0), r.tensor(1)));
    } else {
      return wrap(dispatch_div(r.tensor(0), r.tensor(1), r.tensor(2)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_div_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "div_(Tensor input, Scalar other)",
    "div_(Tensor input, Tensor other)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_div_(r.tensor(0), r.scalar(1)));
  } else if (r.idx == 1) {
    return wrap(dispatch_div_(r.tensor(0), r.tensor(1)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_dot(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "dot(Tensor input, Tensor tensor)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_dot(r.tensor(0), r.tensor(1)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_eig(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "eig(Tensor input, bool eigenvectors=False, *, TensorList[2] out=None)",
  });

  PyObject* parsed_args[4];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(2)) {
      return wrap(dispatch_eig(r.tensor(0), r.toBool(1)));
    } else {
      auto results = r.tensorlist_n<2>(2);
      return wrap(dispatch_eig(r.tensor(0), r.toBool(1), results[0], results[1]));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_embedding(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "embedding(Tensor weight, Tensor indices, int64_t padding_idx=-1, bool scale_grad_by_freq=False, bool sparse=False)",
  });

  PyObject* parsed_args[5];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_embedding(r.tensor(0), r.tensor(1), r.toInt64(2), r.toBool(3), r.toBool(4)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_embedding_renorm_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "embedding_renorm_(Tensor input, Tensor indices, double max_norm, double norm_type)",
  });

  PyObject* parsed_args[4];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_embedding_renorm_(r.tensor(0), r.tensor(1), r.toDouble(2), r.toDouble(3)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_eq(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "eq(Tensor input, Scalar other, *, Tensor out=None)",
    "eq(Tensor input, Tensor other, *, Tensor out=None)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(2)) {
      return wrap(dispatch_eq(r.tensor(0), r.scalar(1)));
    } else {
      return wrap(dispatch_eq(r.tensor(0), r.scalar(1), r.tensor(2)));
    }
  } else if (r.idx == 1) {
    if (r.isNone(2)) {
      return wrap(dispatch_eq(r.tensor(0), r.tensor(1)));
    } else {
      return wrap(dispatch_eq(r.tensor(0), r.tensor(1), r.tensor(2)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_eq_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "eq_(Tensor input, Scalar other)",
    "eq_(Tensor input, Tensor other)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_eq_(r.tensor(0), r.scalar(1)));
  } else if (r.idx == 1) {
    return wrap(dispatch_eq_(r.tensor(0), r.tensor(1)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_equal(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "equal(Tensor input, Tensor other)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_equal(r.tensor(0), r.tensor(1)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_erf(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "erf(Tensor input, *, Tensor out=None)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(1)) {
      return wrap(dispatch_erf(r.tensor(0)));
    } else {
      return wrap(dispatch_erf(r.tensor(0), r.tensor(1)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_erf_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "erf_(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_erf_(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_erfinv(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "erfinv(Tensor input, *, Tensor out=None)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(1)) {
      return wrap(dispatch_erfinv(r.tensor(0)));
    } else {
      return wrap(dispatch_erfinv(r.tensor(0), r.tensor(1)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_erfinv_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "erfinv_(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_erfinv_(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_exp(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "exp(Tensor input, *, Tensor out=None)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(1)) {
      return wrap(dispatch_exp(r.tensor(0)));
    } else {
      return wrap(dispatch_exp(r.tensor(0), r.tensor(1)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_exp_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "exp_(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_exp_(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_expand(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "expand(Tensor input, IntList size)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_expand(r.tensor(0), r.intlist(1)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_expand_as(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "expand_as(Tensor input, Tensor other)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_expand_as(r.tensor(0), r.tensor(1)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_expm1(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "expm1(Tensor input, *, Tensor out=None)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(1)) {
      return wrap(dispatch_expm1(r.tensor(0)));
    } else {
      return wrap(dispatch_expm1(r.tensor(0), r.tensor(1)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_expm1_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "expm1_(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_expm1_(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_exponential_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "exponential_(Tensor input, double lambd=1, *, Generator generator=None)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_exponential_(r.tensor(0), r.toDouble(1), r.generator(2)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_eye(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "eye(int64_t n, int64_t m=1, *, Tensor out=None)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(2)) {
      return wrap(dispatch_eye(r.toInt64(0), r.toInt64(1)));
    } else {
      return wrap(dispatch_eye(r.toInt64(0), r.toInt64(1), r.tensor(2)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_fill_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "fill_(Tensor input, Scalar value)",
    "fill_(Tensor input, Tensor value)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_fill_(r.tensor(0), r.scalar(1)));
  } else if (r.idx == 1) {
    return wrap(dispatch_fill_(r.tensor(0), r.tensor(1)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_floor(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "floor(Tensor input, *, Tensor out=None)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(1)) {
      return wrap(dispatch_floor(r.tensor(0)));
    } else {
      return wrap(dispatch_floor(r.tensor(0), r.tensor(1)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_floor_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "floor_(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_floor_(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_fmod(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "fmod(Tensor input, Scalar other, *, Tensor out=None)",
    "fmod(Tensor input, Tensor other, *, Tensor out=None)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(2)) {
      return wrap(dispatch_fmod(r.tensor(0), r.scalar(1)));
    } else {
      return wrap(dispatch_fmod(r.tensor(0), r.scalar(1), r.tensor(2)));
    }
  } else if (r.idx == 1) {
    if (r.isNone(2)) {
      return wrap(dispatch_fmod(r.tensor(0), r.tensor(1)));
    } else {
      return wrap(dispatch_fmod(r.tensor(0), r.tensor(1), r.tensor(2)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_fmod_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "fmod_(Tensor input, Scalar other)",
    "fmod_(Tensor input, Tensor other)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_fmod_(r.tensor(0), r.scalar(1)));
  } else if (r.idx == 1) {
    return wrap(dispatch_fmod_(r.tensor(0), r.tensor(1)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_frac(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "frac(Tensor input, *, Tensor out=None)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(1)) {
      return wrap(dispatch_frac(r.tensor(0)));
    } else {
      return wrap(dispatch_frac(r.tensor(0), r.tensor(1)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_frac_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "frac_(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_frac_(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_gather(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "gather(Tensor input, int64_t dim, Tensor index, *, Tensor out=None)",
  });

  PyObject* parsed_args[4];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(3)) {
      return wrap(dispatch_gather(r.tensor(0), r.toInt64(1), r.tensor(2)));
    } else {
      return wrap(dispatch_gather(r.tensor(0), r.toInt64(1), r.tensor(2), r.tensor(3)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_ge(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "ge(Tensor input, Scalar other, *, Tensor out=None)",
    "ge(Tensor input, Tensor other, *, Tensor out=None)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(2)) {
      return wrap(dispatch_ge(r.tensor(0), r.scalar(1)));
    } else {
      return wrap(dispatch_ge(r.tensor(0), r.scalar(1), r.tensor(2)));
    }
  } else if (r.idx == 1) {
    if (r.isNone(2)) {
      return wrap(dispatch_ge(r.tensor(0), r.tensor(1)));
    } else {
      return wrap(dispatch_ge(r.tensor(0), r.tensor(1), r.tensor(2)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_ge_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "ge_(Tensor input, Scalar other)",
    "ge_(Tensor input, Tensor other)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_ge_(r.tensor(0), r.scalar(1)));
  } else if (r.idx == 1) {
    return wrap(dispatch_ge_(r.tensor(0), r.tensor(1)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_gels(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "gels(Tensor input, Tensor A, *, TensorList[2] out=None)",
  });

  PyObject* parsed_args[4];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(2)) {
      return wrap(dispatch_gels(r.tensor(0), r.tensor(1)));
    } else {
      auto results = r.tensorlist_n<2>(2);
      return wrap(dispatch_gels(r.tensor(0), r.tensor(1), results[0], results[1]));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_geometric_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "geometric_(Tensor input, double p, *, Generator generator=None)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_geometric_(r.tensor(0), r.toDouble(1), r.generator(2)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_geqrf(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "geqrf(Tensor input, *, TensorList[2] out=None)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(1)) {
      return wrap(dispatch_geqrf(r.tensor(0)));
    } else {
      auto results = r.tensorlist_n<2>(1);
      return wrap(dispatch_geqrf(r.tensor(0), results[0], results[1]));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_ger(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "ger(Tensor input, Tensor vec2, *, Tensor out=None)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(2)) {
      return wrap(dispatch_ger(r.tensor(0), r.tensor(1)));
    } else {
      return wrap(dispatch_ger(r.tensor(0), r.tensor(1), r.tensor(2)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_gesv(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "gesv(Tensor input, Tensor A, *, TensorList[2] out=None)",
  });

  PyObject* parsed_args[4];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(2)) {
      return wrap(dispatch_gesv(r.tensor(0), r.tensor(1)));
    } else {
      auto results = r.tensorlist_n<2>(2);
      return wrap(dispatch_gesv(r.tensor(0), r.tensor(1), results[0], results[1]));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_get_device(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "get_device(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_get_device(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_gt(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "gt(Tensor input, Scalar other, *, Tensor out=None)",
    "gt(Tensor input, Tensor other, *, Tensor out=None)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(2)) {
      return wrap(dispatch_gt(r.tensor(0), r.scalar(1)));
    } else {
      return wrap(dispatch_gt(r.tensor(0), r.scalar(1), r.tensor(2)));
    }
  } else if (r.idx == 1) {
    if (r.isNone(2)) {
      return wrap(dispatch_gt(r.tensor(0), r.tensor(1)));
    } else {
      return wrap(dispatch_gt(r.tensor(0), r.tensor(1), r.tensor(2)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_gt_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "gt_(Tensor input, Scalar other)",
    "gt_(Tensor input, Tensor other)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_gt_(r.tensor(0), r.scalar(1)));
  } else if (r.idx == 1) {
    return wrap(dispatch_gt_(r.tensor(0), r.tensor(1)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_histc(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "histc(Tensor input, int64_t bins=100, Scalar min=0, Scalar max=0, *, Tensor out=None)",
  });

  PyObject* parsed_args[5];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(4)) {
      return wrap(dispatch_histc(r.tensor(0), r.toInt64(1), r.scalar(2), r.scalar(3)));
    } else {
      return wrap(dispatch_histc(r.tensor(0), r.toInt64(1), r.scalar(2), r.scalar(3), r.tensor(4)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_index(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "index(Tensor input, TensorList indices)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_index(r.tensor(0), r.tensorlist(1)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_index_add_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "index_add_(Tensor input, int64_t dim, Tensor index, Tensor source)",
  });

  PyObject* parsed_args[4];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_index_add_(r.tensor(0), r.toInt64(1), r.tensor(2), r.tensor(3)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_index_copy_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "index_copy_(Tensor input, int64_t dim, Tensor index, Tensor source)",
  });

  PyObject* parsed_args[4];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_index_copy_(r.tensor(0), r.toInt64(1), r.tensor(2), r.tensor(3)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_index_fill_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "index_fill_(Tensor input, int64_t dim, Tensor index, Scalar value)",
    "index_fill_(Tensor input, int64_t dim, Tensor index, Tensor value)",
  });

  PyObject* parsed_args[4];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_index_fill_(r.tensor(0), r.toInt64(1), r.tensor(2), r.scalar(3)));
  } else if (r.idx == 1) {
    return wrap(dispatch_index_fill_(r.tensor(0), r.toInt64(1), r.tensor(2), r.tensor(3)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_index_put_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "index_put_(Tensor input, TensorList indices, Tensor values)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_index_put_(r.tensor(0), r.tensorlist(1), r.tensor(2)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_index_select(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "index_select(Tensor input, int64_t dim, Tensor index, *, Tensor out=None)",
  });

  PyObject* parsed_args[4];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(3)) {
      return wrap(dispatch_index_select(r.tensor(0), r.toInt64(1), r.tensor(2)));
    } else {
      return wrap(dispatch_index_select(r.tensor(0), r.toInt64(1), r.tensor(2), r.tensor(3)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_inverse(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "inverse(Tensor input, *, Tensor out=None)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(1)) {
      return wrap(dispatch_inverse(r.tensor(0)));
    } else {
      return wrap(dispatch_inverse(r.tensor(0), r.tensor(1)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_is_contiguous(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "is_contiguous(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_is_contiguous(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_is_distributed(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "is_distributed(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_is_distributed(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_is_nonzero(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "is_nonzero(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_is_nonzero(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_is_same_size(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "is_same_size(Tensor input, Tensor other)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_is_same_size(r.tensor(0), r.tensor(1)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_is_set_to(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "is_set_to(Tensor input, Tensor tensor)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_is_set_to(r.tensor(0), r.tensor(1)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_is_signed(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "is_signed(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_is_signed(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_kthvalue(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "kthvalue(Tensor input, int64_t k, int64_t dim=-1, bool keepdim=False, *, TensorList[2] out=None)",
  });

  PyObject* parsed_args[6];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(4)) {
      return wrap(dispatch_kthvalue(r.tensor(0), r.toInt64(1), r.toInt64(2), r.toBool(3)));
    } else {
      auto results = r.tensorlist_n<2>(4);
      return wrap(dispatch_kthvalue(r.tensor(0), r.toInt64(1), r.toInt64(2), r.toBool(3), results[0], results[1]));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_le(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "le(Tensor input, Scalar other, *, Tensor out=None)",
    "le(Tensor input, Tensor other, *, Tensor out=None)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(2)) {
      return wrap(dispatch_le(r.tensor(0), r.scalar(1)));
    } else {
      return wrap(dispatch_le(r.tensor(0), r.scalar(1), r.tensor(2)));
    }
  } else if (r.idx == 1) {
    if (r.isNone(2)) {
      return wrap(dispatch_le(r.tensor(0), r.tensor(1)));
    } else {
      return wrap(dispatch_le(r.tensor(0), r.tensor(1), r.tensor(2)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_le_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "le_(Tensor input, Scalar other)",
    "le_(Tensor input, Tensor other)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_le_(r.tensor(0), r.scalar(1)));
  } else if (r.idx == 1) {
    return wrap(dispatch_le_(r.tensor(0), r.tensor(1)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_lerp(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "lerp(Tensor input, Tensor end, Scalar weight, *, Tensor out=None)",
  });

  PyObject* parsed_args[4];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(3)) {
      return wrap(dispatch_lerp(r.tensor(0), r.tensor(1), r.scalar(2)));
    } else {
      return wrap(dispatch_lerp(r.tensor(0), r.tensor(1), r.scalar(2), r.tensor(3)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_lerp_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "lerp_(Tensor input, Tensor end, Scalar weight)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_lerp_(r.tensor(0), r.tensor(1), r.scalar(2)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_lgamma(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "lgamma(Tensor input, *, Tensor out=None)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(1)) {
      return wrap(dispatch_lgamma(r.tensor(0)));
    } else {
      return wrap(dispatch_lgamma(r.tensor(0), r.tensor(1)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_lgamma_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "lgamma_(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_lgamma_(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_linspace(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "linspace(Scalar start, Scalar end, int64_t steps=100, *, Tensor out=None)",
  });

  PyObject* parsed_args[4];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(3)) {
      return wrap(dispatch_linspace(r.scalar(0), r.scalar(1), r.toInt64(2)));
    } else {
      return wrap(dispatch_linspace(r.scalar(0), r.scalar(1), r.toInt64(2), r.tensor(3)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_log(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "log(Tensor input, *, Tensor out=None)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(1)) {
      return wrap(dispatch_log(r.tensor(0)));
    } else {
      return wrap(dispatch_log(r.tensor(0), r.tensor(1)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_log1p(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "log1p(Tensor input, *, Tensor out=None)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(1)) {
      return wrap(dispatch_log1p(r.tensor(0)));
    } else {
      return wrap(dispatch_log1p(r.tensor(0), r.tensor(1)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_log1p_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "log1p_(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_log1p_(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_log_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "log_(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_log_(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_log_normal_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "log_normal_(Tensor input, double mean=1, double std=2, *, Generator generator=None)",
  });

  PyObject* parsed_args[4];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_log_normal_(r.tensor(0), r.toDouble(1), r.toDouble(2), r.generator(3)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_logspace(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "logspace(Scalar start, Scalar end, int64_t steps=100, *, Tensor out=None)",
  });

  PyObject* parsed_args[4];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(3)) {
      return wrap(dispatch_logspace(r.scalar(0), r.scalar(1), r.toInt64(2)));
    } else {
      return wrap(dispatch_logspace(r.scalar(0), r.scalar(1), r.toInt64(2), r.tensor(3)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_lt(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "lt(Tensor input, Scalar other, *, Tensor out=None)",
    "lt(Tensor input, Tensor other, *, Tensor out=None)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(2)) {
      return wrap(dispatch_lt(r.tensor(0), r.scalar(1)));
    } else {
      return wrap(dispatch_lt(r.tensor(0), r.scalar(1), r.tensor(2)));
    }
  } else if (r.idx == 1) {
    if (r.isNone(2)) {
      return wrap(dispatch_lt(r.tensor(0), r.tensor(1)));
    } else {
      return wrap(dispatch_lt(r.tensor(0), r.tensor(1), r.tensor(2)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_lt_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "lt_(Tensor input, Scalar other)",
    "lt_(Tensor input, Tensor other)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_lt_(r.tensor(0), r.scalar(1)));
  } else if (r.idx == 1) {
    return wrap(dispatch_lt_(r.tensor(0), r.tensor(1)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_masked_fill_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "masked_fill_(Tensor input, Tensor mask, Scalar value)",
    "masked_fill_(Tensor input, Tensor mask, Tensor value)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_masked_fill_(r.tensor(0), r.tensor(1), r.scalar(2)));
  } else if (r.idx == 1) {
    return wrap(dispatch_masked_fill_(r.tensor(0), r.tensor(1), r.tensor(2)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_masked_scatter_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "masked_scatter_(Tensor input, Tensor mask, Tensor source)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_masked_scatter_(r.tensor(0), r.tensor(1), r.tensor(2)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_masked_select(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "masked_select(Tensor input, Tensor mask, *, Tensor out=None)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(2)) {
      return wrap(dispatch_masked_select(r.tensor(0), r.tensor(1)));
    } else {
      return wrap(dispatch_masked_select(r.tensor(0), r.tensor(1), r.tensor(2)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_matmul(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "matmul(Tensor input, Tensor other)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_matmul(r.tensor(0), r.tensor(1)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_max(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "max(Tensor input)",
    "max(Tensor input, Tensor other, *, Tensor out=None)",
    "max(Tensor input, int64_t dim, bool keepdim=False, *, TensorList[2] out=None)",
  });

  PyObject* parsed_args[5];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_max(r.tensor(0)));
  } else if (r.idx == 1) {
    if (r.isNone(2)) {
      return wrap(dispatch_max(r.tensor(0), r.tensor(1)));
    } else {
      return wrap(dispatch_max(r.tensor(0), r.tensor(1), r.tensor(2)));
    }
  } else if (r.idx == 2) {
    if (r.isNone(3)) {
      return wrap(dispatch_max(r.tensor(0), r.toInt64(1), r.toBool(2)));
    } else {
      auto results = r.tensorlist_n<2>(3);
      return wrap(dispatch_max(r.tensor(0), r.toInt64(1), r.toBool(2), results[0], results[1]));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_max_pool1d(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "max_pool1d(Tensor input, IntList[1] kernel_size, IntList[1] stride=None, IntList[1] padding=0, IntList[1] dilation=1, bool ceil_mode=False)",
  });

  PyObject* parsed_args[6];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_max_pool1d(r.tensor(0), r.intlist(1), r.intlist(2), r.intlist(3), r.intlist(4), r.toBool(5)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_mean(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "mean(Tensor input)",
    "mean(Tensor input, int64_t dim, bool keepdim=False, *, Tensor out=None)",
  });

  PyObject* parsed_args[4];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_mean(r.tensor(0)));
  } else if (r.idx == 1) {
    if (r.isNone(3)) {
      return wrap(dispatch_mean(r.tensor(0), r.toInt64(1), r.toBool(2)));
    } else {
      return wrap(dispatch_mean(r.tensor(0), r.toInt64(1), r.toBool(2), r.tensor(3)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_median(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "median(Tensor input)",
    "median(Tensor input, int64_t dim, bool keepdim=False, *, TensorList[2] out=None)",
  });

  PyObject* parsed_args[5];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_median(r.tensor(0)));
  } else if (r.idx == 1) {
    if (r.isNone(3)) {
      return wrap(dispatch_median(r.tensor(0), r.toInt64(1), r.toBool(2)));
    } else {
      auto results = r.tensorlist_n<2>(3);
      return wrap(dispatch_median(r.tensor(0), r.toInt64(1), r.toBool(2), results[0], results[1]));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_min(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "min(Tensor input)",
    "min(Tensor input, Tensor other, *, Tensor out=None)",
    "min(Tensor input, int64_t dim, bool keepdim=False, *, TensorList[2] out=None)",
  });

  PyObject* parsed_args[5];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_min(r.tensor(0)));
  } else if (r.idx == 1) {
    if (r.isNone(2)) {
      return wrap(dispatch_min(r.tensor(0), r.tensor(1)));
    } else {
      return wrap(dispatch_min(r.tensor(0), r.tensor(1), r.tensor(2)));
    }
  } else if (r.idx == 2) {
    if (r.isNone(3)) {
      return wrap(dispatch_min(r.tensor(0), r.toInt64(1), r.toBool(2)));
    } else {
      auto results = r.tensorlist_n<2>(3);
      return wrap(dispatch_min(r.tensor(0), r.toInt64(1), r.toBool(2), results[0], results[1]));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_mm(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "mm(Tensor input, Tensor mat2, *, Tensor out=None)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(2)) {
      return wrap(dispatch_mm(r.tensor(0), r.tensor(1)));
    } else {
      return wrap(dispatch_mm(r.tensor(0), r.tensor(1), r.tensor(2)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_mode(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "mode(Tensor input, int64_t dim=-1, bool keepdim=False, *, TensorList[2] out=None)",
  });

  PyObject* parsed_args[5];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(3)) {
      return wrap(dispatch_mode(r.tensor(0), r.toInt64(1), r.toBool(2)));
    } else {
      auto results = r.tensorlist_n<2>(3);
      return wrap(dispatch_mode(r.tensor(0), r.toInt64(1), r.toBool(2), results[0], results[1]));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_mul(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "mul(Tensor input, Scalar other, *, Tensor out=None)",
    "mul(Tensor input, Tensor other, *, Tensor out=None)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(2)) {
      return wrap(dispatch_mul(r.tensor(0), r.scalar(1)));
    } else {
      return wrap(dispatch_mul(r.tensor(0), r.scalar(1), r.tensor(2)));
    }
  } else if (r.idx == 1) {
    if (r.isNone(2)) {
      return wrap(dispatch_mul(r.tensor(0), r.tensor(1)));
    } else {
      return wrap(dispatch_mul(r.tensor(0), r.tensor(1), r.tensor(2)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_mul_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "mul_(Tensor input, Scalar other)",
    "mul_(Tensor input, Tensor other)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_mul_(r.tensor(0), r.scalar(1)));
  } else if (r.idx == 1) {
    return wrap(dispatch_mul_(r.tensor(0), r.tensor(1)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_multinomial(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "multinomial(Tensor input, int64_t num_samples, bool replacement=False, *, Generator generator=None, Tensor out=None)",
  });

  PyObject* parsed_args[5];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(4)) {
      return wrap(dispatch_multinomial(r.tensor(0), r.toInt64(1), r.toBool(2), r.generator(3)));
    } else {
      return wrap(dispatch_multinomial(r.tensor(0), r.toInt64(1), r.toBool(2), r.generator(3), r.tensor(4)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_mv(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "mv(Tensor input, Tensor vec, *, Tensor out=None)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(2)) {
      return wrap(dispatch_mv(r.tensor(0), r.tensor(1)));
    } else {
      return wrap(dispatch_mv(r.tensor(0), r.tensor(1), r.tensor(2)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_narrow(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "narrow(Tensor input, int64_t dim, int64_t start, int64_t length)",
  });

  PyObject* parsed_args[4];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_narrow(r.tensor(0), r.toInt64(1), r.toInt64(2), r.toInt64(3)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_ne(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "ne(Tensor input, Scalar other, *, Tensor out=None)",
    "ne(Tensor input, Tensor other, *, Tensor out=None)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(2)) {
      return wrap(dispatch_ne(r.tensor(0), r.scalar(1)));
    } else {
      return wrap(dispatch_ne(r.tensor(0), r.scalar(1), r.tensor(2)));
    }
  } else if (r.idx == 1) {
    if (r.isNone(2)) {
      return wrap(dispatch_ne(r.tensor(0), r.tensor(1)));
    } else {
      return wrap(dispatch_ne(r.tensor(0), r.tensor(1), r.tensor(2)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_ne_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "ne_(Tensor input, Scalar other)",
    "ne_(Tensor input, Tensor other)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_ne_(r.tensor(0), r.scalar(1)));
  } else if (r.idx == 1) {
    return wrap(dispatch_ne_(r.tensor(0), r.tensor(1)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_neg(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "neg(Tensor input, *, Tensor out=None)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(1)) {
      return wrap(dispatch_neg(r.tensor(0)));
    } else {
      return wrap(dispatch_neg(r.tensor(0), r.tensor(1)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_neg_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "neg_(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_neg_(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_nnpack_spatial_convolution(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "nnpack_spatial_convolution(Tensor input, Tensor weight, Tensor? bias, int64_t kW, int64_t kH, int64_t padW, int64_t padH)",
  });

  PyObject* parsed_args[7];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_nnpack_spatial_convolution(r.tensor(0), r.tensor(1), r.tensor(2), r.toInt64(3), r.toInt64(4), r.toInt64(5), r.toInt64(6)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_nnpack_spatial_convolution_backward_input(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "nnpack_spatial_convolution_backward_input(Tensor input, Tensor grad_output, Tensor weight, int64_t kW, int64_t kH, int64_t padW, int64_t padH)",
  });

  PyObject* parsed_args[7];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_nnpack_spatial_convolution_backward_input(r.tensor(0), r.tensor(1), r.tensor(2), r.toInt64(3), r.toInt64(4), r.toInt64(5), r.toInt64(6)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_nnpack_spatial_convolution_backward_weight(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "nnpack_spatial_convolution_backward_weight(Tensor input, IntList weight_size, Tensor grad_output, int64_t kW, int64_t kH, int64_t padW, int64_t padH)",
  });

  PyObject* parsed_args[7];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_nnpack_spatial_convolution_backward_weight(r.tensor(0), r.intlist(1), r.tensor(2), r.toInt64(3), r.toInt64(4), r.toInt64(5), r.toInt64(6)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_nonzero(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "nonzero(Tensor input, *, Tensor out=None)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(1)) {
      return wrap(dispatch_nonzero(r.tensor(0)));
    } else {
      return wrap(dispatch_nonzero(r.tensor(0), r.tensor(1)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_norm(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "norm(Tensor input, Scalar p=2)",
    "norm(Tensor input, Scalar p=None, int64_t dim, bool keepdim=False, *, Tensor out=None)",
  });

  PyObject* parsed_args[5];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_norm(r.tensor(0), r.scalar(1)));
  } else if (r.idx == 1) {
    if (r.isNone(4)) {
      auto self = r.tensor(0);
      auto p = r.scalarWithDefault(1, 2);
      auto dim = r.toInt64(2);
      auto keepdim = r.toBool(3);
      return wrap(dispatch_norm(self, p, dim, keepdim));
    } else {
      auto self = r.tensor(0);
      auto p = r.scalarWithDefault(1, 2);
      auto dim = r.toInt64(2);
      auto keepdim = r.toBool(3);
      return wrap(dispatch_norm(self, p, dim, keepdim, r.tensor(4)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_normal(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "normal(Tensor mean, Tensor std, *, Generator generator=None, Tensor out=None)",
    "normal(Tensor mean, double std=1, *, Generator generator=None, Tensor out=None)",
    "normal(double mean, Tensor std, *, Generator generator=None, Tensor out=None)",
  });

  PyObject* parsed_args[4];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(3)) {
      return wrap(dispatch_normal(r.tensor(0), r.tensor(1), r.generator(2)));
    } else {
      return wrap(dispatch_normal(r.tensor(0), r.tensor(1), r.generator(2), r.tensor(3)));
    }
  } else if (r.idx == 1) {
    if (r.isNone(3)) {
      return wrap(dispatch_normal(r.tensor(0), r.toDouble(1), r.generator(2)));
    } else {
      return wrap(dispatch_normal(r.tensor(0), r.toDouble(1), r.generator(2), r.tensor(3)));
    }
  } else if (r.idx == 2) {
    if (r.isNone(3)) {
      return wrap(dispatch_normal(r.toDouble(0), r.tensor(1), r.generator(2)));
    } else {
      return wrap(dispatch_normal(r.toDouble(0), r.tensor(1), r.generator(2), r.tensor(3)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_normal_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "normal_(Tensor input, double mean=0, double std=1, *, Generator generator=None)",
  });

  PyObject* parsed_args[4];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_normal_(r.tensor(0), r.toDouble(1), r.toDouble(2), r.generator(3)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_numel(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "numel(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_numel(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_ones(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "ones(IntList size, *, Tensor out=None)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(1)) {
      return wrap(dispatch_ones(r.intlist(0)));
    } else {
      return wrap(dispatch_ones(r.intlist(0), r.tensor(1)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_ones_like(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "ones_like(Tensor input, *, Tensor out=None)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(1)) {
      return wrap(dispatch_ones_like(r.tensor(0)));
    } else {
      return wrap(dispatch_ones_like(r.tensor(0), r.tensor(1)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_orgqr(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "orgqr(Tensor input, Tensor input2, *, Tensor out=None)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(2)) {
      return wrap(dispatch_orgqr(r.tensor(0), r.tensor(1)));
    } else {
      return wrap(dispatch_orgqr(r.tensor(0), r.tensor(1), r.tensor(2)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_ormqr(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "ormqr(Tensor input, Tensor input2, Tensor input3, bool left=True, bool transpose=False, *, Tensor out=None)",
  });

  PyObject* parsed_args[6];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(5)) {
      return wrap(dispatch_ormqr(r.tensor(0), r.tensor(1), r.tensor(2), r.toBool(3), r.toBool(4)));
    } else {
      return wrap(dispatch_ormqr(r.tensor(0), r.tensor(1), r.tensor(2), r.toBool(3), r.toBool(4), r.tensor(5)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_permute(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "permute(Tensor input, IntList dims)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_permute(r.tensor(0), r.intlist(1)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_pin_memory(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "pin_memory(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_pin_memory(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_polygamma(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "polygamma(int64_t n, Tensor input, *, Tensor out=None)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(2)) {
      return wrap(dispatch_polygamma(r.toInt64(0), r.tensor(1)));
    } else {
      return wrap(dispatch_polygamma(r.toInt64(0), r.tensor(1), r.tensor(2)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_polygamma_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "polygamma_(Tensor input, int64_t n)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_polygamma_(r.tensor(0), r.toInt64(1)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_potrf(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "potrf(Tensor input, bool upper=True, *, Tensor out=None)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(2)) {
      return wrap(dispatch_potrf(r.tensor(0), r.toBool(1)));
    } else {
      return wrap(dispatch_potrf(r.tensor(0), r.toBool(1), r.tensor(2)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_potri(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "potri(Tensor input, bool upper=True, *, Tensor out=None)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(2)) {
      return wrap(dispatch_potri(r.tensor(0), r.toBool(1)));
    } else {
      return wrap(dispatch_potri(r.tensor(0), r.toBool(1), r.tensor(2)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_potrs(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "potrs(Tensor input, Tensor input2, bool upper=True, *, Tensor out=None)",
  });

  PyObject* parsed_args[4];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(3)) {
      return wrap(dispatch_potrs(r.tensor(0), r.tensor(1), r.toBool(2)));
    } else {
      return wrap(dispatch_potrs(r.tensor(0), r.tensor(1), r.toBool(2), r.tensor(3)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_pow(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "pow(Tensor input, Scalar exponent, *, Tensor out=None)",
    "pow(Tensor input, Tensor exponent, *, Tensor out=None)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(2)) {
      return wrap(dispatch_pow(r.tensor(0), r.scalar(1)));
    } else {
      return wrap(dispatch_pow(r.tensor(0), r.scalar(1), r.tensor(2)));
    }
  } else if (r.idx == 1) {
    if (r.isNone(2)) {
      return wrap(dispatch_pow(r.tensor(0), r.tensor(1)));
    } else {
      return wrap(dispatch_pow(r.tensor(0), r.tensor(1), r.tensor(2)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_pow_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "pow_(Tensor input, Scalar exponent)",
    "pow_(Tensor input, Tensor exponent)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_pow_(r.tensor(0), r.scalar(1)));
  } else if (r.idx == 1) {
    return wrap(dispatch_pow_(r.tensor(0), r.tensor(1)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_prod(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "prod(Tensor input)",
    "prod(Tensor input, int64_t dim, bool keepdim=False, *, Tensor out=None)",
  });

  PyObject* parsed_args[4];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_prod(r.tensor(0)));
  } else if (r.idx == 1) {
    if (r.isNone(3)) {
      return wrap(dispatch_prod(r.tensor(0), r.toInt64(1), r.toBool(2)));
    } else {
      return wrap(dispatch_prod(r.tensor(0), r.toInt64(1), r.toBool(2), r.tensor(3)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_pstrf(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "pstrf(Tensor input, bool upper=True, Scalar tol=-1, *, TensorList[2] out=None)",
  });

  PyObject* parsed_args[5];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(3)) {
      return wrap(dispatch_pstrf(r.tensor(0), r.toBool(1), r.scalar(2)));
    } else {
      auto results = r.tensorlist_n<2>(3);
      return wrap(dispatch_pstrf(r.tensor(0), r.toBool(1), r.scalar(2), results[0], results[1]));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_put_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "put_(Tensor input, Tensor index, Tensor source, bool accumulate=False)",
  });

  PyObject* parsed_args[4];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_put_(r.tensor(0), r.tensor(1), r.tensor(2), r.toBool(3)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_qr(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "qr(Tensor input, *, TensorList[2] out=None)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(1)) {
      return wrap(dispatch_qr(r.tensor(0)));
    } else {
      auto results = r.tensorlist_n<2>(1);
      return wrap(dispatch_qr(r.tensor(0), results[0], results[1]));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_rand(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "rand(IntList size, *, Generator generator=None, Tensor out=None)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(2)) {
      return wrap(dispatch_rand(r.intlist(0), r.generator(1)));
    } else {
      return wrap(dispatch_rand(r.intlist(0), r.generator(1), r.tensor(2)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_randn(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "randn(IntList size, *, Generator generator=None, Tensor out=None)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(2)) {
      return wrap(dispatch_randn(r.intlist(0), r.generator(1)));
    } else {
      return wrap(dispatch_randn(r.intlist(0), r.generator(1), r.tensor(2)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_random_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "random_(Tensor input, *, Generator generator=None)",
    "random_(Tensor input, int64_t from, int64_t to, *, Generator generator=None)",
    "random_(Tensor input, int64_t to, *, Generator generator=None)",
  });

  PyObject* parsed_args[4];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_random_(r.tensor(0), r.generator(1)));
  } else if (r.idx == 1) {
    return wrap(dispatch_random_(r.tensor(0), r.toInt64(1), r.toInt64(2), r.generator(3)));
  } else if (r.idx == 2) {
    return wrap(dispatch_random_(r.tensor(0), r.toInt64(1), r.generator(2)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_randperm(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "randperm(int64_t n, *, Generator generator=None, Tensor out=None)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(2)) {
      return wrap(dispatch_randperm(r.toInt64(0), r.generator(1)));
    } else {
      return wrap(dispatch_randperm(r.toInt64(0), r.generator(1), r.tensor(2)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_range(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "range(Scalar start, Scalar end, Scalar step=1, *, Tensor out=None)",
  });

  PyObject* parsed_args[4];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(3)) {
      return wrap(dispatch_range(r.scalar(0), r.scalar(1), r.scalar(2)));
    } else {
      return wrap(dispatch_range(r.scalar(0), r.scalar(1), r.scalar(2), r.tensor(3)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_reciprocal(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "reciprocal(Tensor input, *, Tensor out=None)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(1)) {
      return wrap(dispatch_reciprocal(r.tensor(0)));
    } else {
      return wrap(dispatch_reciprocal(r.tensor(0), r.tensor(1)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_reciprocal_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "reciprocal_(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_reciprocal_(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_remainder(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "remainder(Tensor input, Scalar other, *, Tensor out=None)",
    "remainder(Tensor input, Tensor other, *, Tensor out=None)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(2)) {
      return wrap(dispatch_remainder(r.tensor(0), r.scalar(1)));
    } else {
      return wrap(dispatch_remainder(r.tensor(0), r.scalar(1), r.tensor(2)));
    }
  } else if (r.idx == 1) {
    if (r.isNone(2)) {
      return wrap(dispatch_remainder(r.tensor(0), r.tensor(1)));
    } else {
      return wrap(dispatch_remainder(r.tensor(0), r.tensor(1), r.tensor(2)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_remainder_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "remainder_(Tensor input, Scalar other)",
    "remainder_(Tensor input, Tensor other)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_remainder_(r.tensor(0), r.scalar(1)));
  } else if (r.idx == 1) {
    return wrap(dispatch_remainder_(r.tensor(0), r.tensor(1)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_renorm(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "renorm(Tensor input, Scalar p, int64_t dim, Scalar maxnorm, *, Tensor out=None)",
  });

  PyObject* parsed_args[5];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(4)) {
      return wrap(dispatch_renorm(r.tensor(0), r.scalar(1), r.toInt64(2), r.scalar(3)));
    } else {
      return wrap(dispatch_renorm(r.tensor(0), r.scalar(1), r.toInt64(2), r.scalar(3), r.tensor(4)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_renorm_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "renorm_(Tensor input, Scalar p, int64_t dim, Scalar maxnorm)",
  });

  PyObject* parsed_args[4];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_renorm_(r.tensor(0), r.scalar(1), r.toInt64(2), r.scalar(3)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_reshape_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "reshape_(Tensor input, IntList size, IntList stride)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_reshape_(r.tensor(0), r.intlist(1), r.intlist(2)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_resize_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "resize_(Tensor input, IntList size)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_resize_(r.tensor(0), r.intlist(1)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_resize_as_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "resize_as_(Tensor input, Tensor the_template)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_resize_as_(r.tensor(0), r.tensor(1)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_round(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "round(Tensor input, *, Tensor out=None)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(1)) {
      return wrap(dispatch_round(r.tensor(0)));
    } else {
      return wrap(dispatch_round(r.tensor(0), r.tensor(1)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_round_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "round_(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_round_(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_rrelu(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "rrelu(Tensor input, Scalar lower=0.125, Scalar upper=0.3333333333333333, bool training=False, Generator generator=None)",
  });

  PyObject* parsed_args[5];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_rrelu(r.tensor(0), r.scalar(1), r.scalar(2), r.toBool(3), r.generator(4)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_rrelu_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "rrelu_(Tensor input, Scalar lower=0.125, Scalar upper=0.3333333333333333, bool training=False, Generator generator=None)",
  });

  PyObject* parsed_args[5];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_rrelu_(r.tensor(0), r.scalar(1), r.scalar(2), r.toBool(3), r.generator(4)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_rsqrt(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "rsqrt(Tensor input, *, Tensor out=None)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(1)) {
      return wrap(dispatch_rsqrt(r.tensor(0)));
    } else {
      return wrap(dispatch_rsqrt(r.tensor(0), r.tensor(1)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_rsqrt_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "rsqrt_(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_rsqrt_(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_scatter_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "scatter_(Tensor input, int64_t dim, Tensor index, Scalar value)",
    "scatter_(Tensor input, int64_t dim, Tensor index, Tensor src)",
  });

  PyObject* parsed_args[4];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_scatter_(r.tensor(0), r.toInt64(1), r.tensor(2), r.scalar(3)));
  } else if (r.idx == 1) {
    return wrap(dispatch_scatter_(r.tensor(0), r.toInt64(1), r.tensor(2), r.tensor(3)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_scatter_add_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "scatter_add_(Tensor input, int64_t dim, Tensor index, Tensor src)",
  });

  PyObject* parsed_args[4];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_scatter_add_(r.tensor(0), r.toInt64(1), r.tensor(2), r.tensor(3)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_select(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "select(Tensor input, int64_t dim, int64_t index)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_select(r.tensor(0), r.toInt64(1), r.toInt64(2)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_selu(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "selu(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_selu(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_selu_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "selu_(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_selu_(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_set_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "set_(Tensor input)",
    "set_(Tensor input, Storage sourceStorage, int64_t storage_offset, IntList size, IntList stride=None)",
    "set_(Tensor input, Storage storage)",
    "set_(Tensor input, Tensor source)",
  });

  PyObject* parsed_args[5];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_set_(r.tensor(0)));
  } else if (r.idx == 1) {
    return wrap(dispatch_set_(r.tensor(0), *r.storage(1), r.toInt64(2), r.intlist(3), r.intlist(4)));
  } else if (r.idx == 2) {
    return wrap(dispatch_set_(r.tensor(0), *r.storage(1)));
  } else if (r.idx == 3) {
    return wrap(dispatch_set_(r.tensor(0), r.tensor(1)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_sigmoid(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "sigmoid(Tensor input, *, Tensor out=None)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(1)) {
      return wrap(dispatch_sigmoid(r.tensor(0)));
    } else {
      return wrap(dispatch_sigmoid(r.tensor(0), r.tensor(1)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_sigmoid_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "sigmoid_(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_sigmoid_(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_sign(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "sign(Tensor input, *, Tensor out=None)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(1)) {
      return wrap(dispatch_sign(r.tensor(0)));
    } else {
      return wrap(dispatch_sign(r.tensor(0), r.tensor(1)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_sign_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "sign_(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_sign_(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_sin(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "sin(Tensor input, *, Tensor out=None)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(1)) {
      return wrap(dispatch_sin(r.tensor(0)));
    } else {
      return wrap(dispatch_sin(r.tensor(0), r.tensor(1)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_sin_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "sin_(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_sin_(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_sinh(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "sinh(Tensor input, *, Tensor out=None)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(1)) {
      return wrap(dispatch_sinh(r.tensor(0)));
    } else {
      return wrap(dispatch_sinh(r.tensor(0), r.tensor(1)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_sinh_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "sinh_(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_sinh_(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_slice(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "slice(Tensor input, int64_t dim=0, int64_t start=0, int64_t end=9223372036854775807, int64_t step=1)",
  });

  PyObject* parsed_args[5];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_slice(r.tensor(0), r.toInt64(1), r.toInt64(2), r.toInt64(3), r.toInt64(4)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_sort(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "sort(Tensor input, int64_t dim=-1, bool descending=False, *, TensorList[2] out=None)",
  });

  PyObject* parsed_args[5];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(3)) {
      return wrap(dispatch_sort(r.tensor(0), r.toInt64(1), r.toBool(2)));
    } else {
      auto results = r.tensorlist_n<2>(3);
      return wrap(dispatch_sort(r.tensor(0), r.toInt64(1), r.toBool(2), results[0], results[1]));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_sparse_coo_tensor(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "sparse_coo_tensor(Tensor indices, Tensor values, IntList size)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_sparse_coo_tensor(r.tensor(0), r.tensor(1), r.intlist(2)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_split(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "split(Tensor input, int64_t split_size, int64_t dim=0)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_split(r.tensor(0), r.toInt64(1), r.toInt64(2)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_sqrt(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "sqrt(Tensor input, *, Tensor out=None)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(1)) {
      return wrap(dispatch_sqrt(r.tensor(0)));
    } else {
      return wrap(dispatch_sqrt(r.tensor(0), r.tensor(1)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_sqrt_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "sqrt_(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_sqrt_(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_squeeze(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "squeeze(Tensor input)",
    "squeeze(Tensor input, int64_t dim)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_squeeze(r.tensor(0)));
  } else if (r.idx == 1) {
    return wrap(dispatch_squeeze(r.tensor(0), r.toInt64(1)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_squeeze_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "squeeze_(Tensor input)",
    "squeeze_(Tensor input, int64_t dim)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_squeeze_(r.tensor(0)));
  } else if (r.idx == 1) {
    return wrap(dispatch_squeeze_(r.tensor(0), r.toInt64(1)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_stack(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "stack(TensorList tensors, int64_t dim=0)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_stack(r.tensorlist(0), r.toInt64(1)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_std(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "std(Tensor input, bool unbiased=True)",
    "std(Tensor input, int64_t dim, bool unbiased=True, bool keepdim=False, *, Tensor out=None)",
  });

  PyObject* parsed_args[5];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_std(r.tensor(0), r.toBool(1)));
  } else if (r.idx == 1) {
    if (r.isNone(4)) {
      return wrap(dispatch_std(r.tensor(0), r.toInt64(1), r.toBool(2), r.toBool(3)));
    } else {
      return wrap(dispatch_std(r.tensor(0), r.toInt64(1), r.toBool(2), r.toBool(3), r.tensor(4)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_stft(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "stft(Tensor input, int64_t frame_length, int64_t hop, int64_t fft_size=None, bool return_onesided=True, Tensor window=None, int64_t pad_end=0)",
  });

  PyObject* parsed_args[7];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    auto self = r.tensor(0);
    auto frame_length = r.toInt64(1);
    auto hop = r.toInt64(2);
    auto fft_size = r.toInt64WithDefault(3, frame_length);
    auto return_onesided = r.toBool(4);
    auto window = r.tensor(5);
    auto pad_end = r.toInt64(6);
    return wrap(dispatch_stft(self, frame_length, hop, fft_size, return_onesided, window, pad_end));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_storage_offset(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "storage_offset(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_storage_offset(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_sub(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "sub(Tensor input, Scalar alpha, Tensor other)|deprecated",
    "sub(Tensor input, Scalar other, *, Scalar alpha=1, Tensor out=None)",
    "sub(Tensor input, Tensor other, *, Scalar alpha=1, Tensor out=None)",
  });

  PyObject* parsed_args[4];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_sub(r.tensor(0), r.scalar(1), r.tensor(2)));
  } else if (r.idx == 1) {
    if (r.isNone(3)) {
      return wrap(dispatch_sub(r.tensor(0), r.scalar(1), r.scalar(2)));
    } else {
      return wrap(dispatch_sub(r.tensor(0), r.scalar(1), r.scalar(2), r.tensor(3)));
    }
  } else if (r.idx == 2) {
    if (r.isNone(3)) {
      return wrap(dispatch_sub(r.tensor(0), r.tensor(1), r.scalar(2)));
    } else {
      return wrap(dispatch_sub(r.tensor(0), r.tensor(1), r.scalar(2), r.tensor(3)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_sub_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "sub_(Tensor input, Scalar alpha, Tensor other)|deprecated",
    "sub_(Tensor input, Scalar other, *, Scalar alpha=1)",
    "sub_(Tensor input, Tensor other, *, Scalar alpha=1)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_sub_(r.tensor(0), r.scalar(1), r.tensor(2)));
  } else if (r.idx == 1) {
    return wrap(dispatch_sub_(r.tensor(0), r.scalar(1), r.scalar(2)));
  } else if (r.idx == 2) {
    return wrap(dispatch_sub_(r.tensor(0), r.tensor(1), r.scalar(2)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_sum(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "sum(Tensor input)",
    "sum(Tensor input, int64_t dim, bool keepdim=False, *, Tensor out=None)",
  });

  PyObject* parsed_args[4];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_sum(r.tensor(0)));
  } else if (r.idx == 1) {
    if (r.isNone(3)) {
      return wrap(dispatch_sum(r.tensor(0), r.toInt64(1), r.toBool(2)));
    } else {
      return wrap(dispatch_sum(r.tensor(0), r.toInt64(1), r.toBool(2), r.tensor(3)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_svd(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "svd(Tensor input, bool some=True, *, TensorList[3] out=None)",
  });

  PyObject* parsed_args[5];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(2)) {
      return wrap(dispatch_svd(r.tensor(0), r.toBool(1)));
    } else {
      auto results = r.tensorlist_n<3>(2);
      return wrap(dispatch_svd(r.tensor(0), r.toBool(1), results[0], results[1], results[2]));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_symeig(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "symeig(Tensor input, bool eigenvectors=False, bool upper=True, *, TensorList[2] out=None)",
  });

  PyObject* parsed_args[5];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(3)) {
      return wrap(dispatch_symeig(r.tensor(0), r.toBool(1), r.toBool(2)));
    } else {
      auto results = r.tensorlist_n<2>(3);
      return wrap(dispatch_symeig(r.tensor(0), r.toBool(1), r.toBool(2), results[0], results[1]));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_t(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "t(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_t(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_t_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "t_(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_t_(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_take(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "take(Tensor input, Tensor index, *, Tensor out=None)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(2)) {
      return wrap(dispatch_take(r.tensor(0), r.tensor(1)));
    } else {
      return wrap(dispatch_take(r.tensor(0), r.tensor(1), r.tensor(2)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_tan(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "tan(Tensor input, *, Tensor out=None)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(1)) {
      return wrap(dispatch_tan(r.tensor(0)));
    } else {
      return wrap(dispatch_tan(r.tensor(0), r.tensor(1)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_tan_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "tan_(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_tan_(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_tanh(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "tanh(Tensor input, *, Tensor out=None)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(1)) {
      return wrap(dispatch_tanh(r.tensor(0)));
    } else {
      return wrap(dispatch_tanh(r.tensor(0), r.tensor(1)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_tanh_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "tanh_(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_tanh_(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_tensor(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "tensor()",
    "tensor(IntList size)",
    "tensor(IntList size, IntList stride)",
    "tensor(Storage storage, int64_t storageOffset, IntList size, IntList stride=None)",
  });

  PyObject* parsed_args[4];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_tensor());
  } else if (r.idx == 1) {
    return wrap(dispatch_tensor(r.intlist(0)));
  } else if (r.idx == 2) {
    return wrap(dispatch_tensor(r.intlist(0), r.intlist(1)));
  } else if (r.idx == 3) {
    return wrap(dispatch_tensor(*r.storage(0), r.toInt64(1), r.intlist(2), r.intlist(3)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_topk(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "topk(Tensor input, int64_t k, int64_t dim=-1, bool largest=True, bool sorted=True, *, TensorList[2] out=None)",
  });

  PyObject* parsed_args[7];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(5)) {
      return wrap(dispatch_topk(r.tensor(0), r.toInt64(1), r.toInt64(2), r.toBool(3), r.toBool(4)));
    } else {
      auto results = r.tensorlist_n<2>(5);
      return wrap(dispatch_topk(r.tensor(0), r.toInt64(1), r.toInt64(2), r.toBool(3), r.toBool(4), results[0], results[1]));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_trace(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "trace(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_trace(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_transpose(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "transpose(Tensor input, int64_t dim0, int64_t dim1)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_transpose(r.tensor(0), r.toInt64(1), r.toInt64(2)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_transpose_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "transpose_(Tensor input, int64_t dim0, int64_t dim1)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_transpose_(r.tensor(0), r.toInt64(1), r.toInt64(2)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_tril(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "tril(Tensor input, int64_t diagonal=0, *, Tensor out=None)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(2)) {
      return wrap(dispatch_tril(r.tensor(0), r.toInt64(1)));
    } else {
      return wrap(dispatch_tril(r.tensor(0), r.toInt64(1), r.tensor(2)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_tril_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "tril_(Tensor input, int64_t diagonal=0)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_tril_(r.tensor(0), r.toInt64(1)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_triu(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "triu(Tensor input, int64_t diagonal=0, *, Tensor out=None)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(2)) {
      return wrap(dispatch_triu(r.tensor(0), r.toInt64(1)));
    } else {
      return wrap(dispatch_triu(r.tensor(0), r.toInt64(1), r.tensor(2)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_triu_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "triu_(Tensor input, int64_t diagonal=0)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_triu_(r.tensor(0), r.toInt64(1)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_trtrs(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "trtrs(Tensor input, Tensor A, bool upper=True, bool transpose=False, bool unitriangular=False, *, TensorList[2] out=None)",
  });

  PyObject* parsed_args[7];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(5)) {
      return wrap(dispatch_trtrs(r.tensor(0), r.tensor(1), r.toBool(2), r.toBool(3), r.toBool(4)));
    } else {
      auto results = r.tensorlist_n<2>(5);
      return wrap(dispatch_trtrs(r.tensor(0), r.tensor(1), r.toBool(2), r.toBool(3), r.toBool(4), results[0], results[1]));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_trunc(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "trunc(Tensor input, *, Tensor out=None)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(1)) {
      return wrap(dispatch_trunc(r.tensor(0)));
    } else {
      return wrap(dispatch_trunc(r.tensor(0), r.tensor(1)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_trunc_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "trunc_(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_trunc_(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_type_as(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "type_as(Tensor input, Tensor other)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_type_as(r.tensor(0), r.tensor(1)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_unfold(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "unfold(Tensor input, int64_t dimension, int64_t size, int64_t step)",
  });

  PyObject* parsed_args[4];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_unfold(r.tensor(0), r.toInt64(1), r.toInt64(2), r.toInt64(3)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_uniform_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "uniform_(Tensor input, double from=0, double to=1, *, Generator generator=None)",
  });

  PyObject* parsed_args[4];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_uniform_(r.tensor(0), r.toDouble(1), r.toDouble(2), r.generator(3)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_unsqueeze(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "unsqueeze(Tensor input, int64_t dim)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_unsqueeze(r.tensor(0), r.toInt64(1)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_unsqueeze_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "unsqueeze_(Tensor input, int64_t dim)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_unsqueeze_(r.tensor(0), r.toInt64(1)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_var(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "var(Tensor input, bool unbiased=True)",
    "var(Tensor input, int64_t dim, bool unbiased=True, bool keepdim=False, *, Tensor out=None)",
  });

  PyObject* parsed_args[5];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_var(r.tensor(0), r.toBool(1)));
  } else if (r.idx == 1) {
    if (r.isNone(4)) {
      return wrap(dispatch_var(r.tensor(0), r.toInt64(1), r.toBool(2), r.toBool(3)));
    } else {
      return wrap(dispatch_var(r.tensor(0), r.toInt64(1), r.toBool(2), r.toBool(3), r.tensor(4)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_view(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "view(Tensor input, IntList size)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_view(r.tensor(0), r.intlist(1)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_view_as(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "view_as(Tensor input, Tensor other)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_view_as(r.tensor(0), r.tensor(1)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_where(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "where(Tensor condition, Tensor input, Tensor other)",
  });

  PyObject* parsed_args[3];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_where(r.tensor(0), r.tensor(1), r.tensor(2)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_zero_(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "zero_(Tensor input)",
  });

  PyObject* parsed_args[1];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    return wrap(dispatch_zero_(r.tensor(0)));
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_zeros(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "zeros(IntList size, *, Tensor out=None)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(1)) {
      return wrap(dispatch_zeros(r.intlist(0)));
    } else {
      return wrap(dispatch_zeros(r.intlist(0), r.tensor(1)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}
static PyObject * THPVariable_zeros_like(PyObject* self, PyObject* args, PyObject* kwargs)
{
  HANDLE_TH_ERRORS
  static PythonArgParser parser({
    "zeros_like(Tensor input, *, Tensor out=None)",
  });

  PyObject* parsed_args[2];
  auto r = parser.parse(args, kwargs, parsed_args);
  if (r.idx == 0) {
    if (r.isNone(1)) {
      return wrap(dispatch_zeros_like(r.tensor(0)));
    } else {
      return wrap(dispatch_zeros_like(r.tensor(0), r.tensor(1)));
    }
  }
  Py_RETURN_NONE;
  END_HANDLE_TH_ERRORS
}

static PyMethodDef torch_functions[] = {
  {"clamp", (PyCFunction)THPVariable_clamp, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"from_numpy", (PyCFunction)THPVariable_from_numpy, METH_STATIC | METH_O, NULL},
  {"__and__", (PyCFunction)THPVariable___and__, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"__iand__", (PyCFunction)THPVariable___iand__, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"__ilshift__", (PyCFunction)THPVariable___ilshift__, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"__ior__", (PyCFunction)THPVariable___ior__, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"__irshift__", (PyCFunction)THPVariable___irshift__, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"__ixor__", (PyCFunction)THPVariable___ixor__, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"__lshift__", (PyCFunction)THPVariable___lshift__, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"__or__", (PyCFunction)THPVariable___or__, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"__rshift__", (PyCFunction)THPVariable___rshift__, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"__xor__", (PyCFunction)THPVariable___xor__, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"_convolution", (PyCFunction)THPVariable__convolution, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"_convolution_nogroup", (PyCFunction)THPVariable__convolution_nogroup, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"_copy_ignoring_overlaps_", (PyCFunction)THPVariable__copy_ignoring_overlaps_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"_det_with_svd", (PyCFunction)THPVariable__det_with_svd, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"_indices", (PyCFunction)THPVariable__indices, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"_s_where", (PyCFunction)THPVariable__s_where, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"_sparse_mask", (PyCFunction)THPVariable__sparse_mask, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"_standard_gamma", (PyCFunction)THPVariable__standard_gamma, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"_standard_gamma_grad", (PyCFunction)THPVariable__standard_gamma_grad, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"_values", (PyCFunction)THPVariable__values, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"abs", (PyCFunction)THPVariable_abs, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"abs_", (PyCFunction)THPVariable_abs_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"acos", (PyCFunction)THPVariable_acos, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"acos_", (PyCFunction)THPVariable_acos_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"adaptive_avg_pool1d", (PyCFunction)THPVariable_adaptive_avg_pool1d, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"adaptive_max_pool1d", (PyCFunction)THPVariable_adaptive_max_pool1d, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"add", (PyCFunction)THPVariable_add, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"add_", (PyCFunction)THPVariable_add_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"addbmm", (PyCFunction)THPVariable_addbmm, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"addbmm_", (PyCFunction)THPVariable_addbmm_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"addcdiv", (PyCFunction)THPVariable_addcdiv, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"addcdiv_", (PyCFunction)THPVariable_addcdiv_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"addcmul", (PyCFunction)THPVariable_addcmul, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"addcmul_", (PyCFunction)THPVariable_addcmul_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"addmm", (PyCFunction)THPVariable_addmm, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"addmm_", (PyCFunction)THPVariable_addmm_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"addmv", (PyCFunction)THPVariable_addmv, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"addmv_", (PyCFunction)THPVariable_addmv_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"addr", (PyCFunction)THPVariable_addr, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"addr_", (PyCFunction)THPVariable_addr_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"all", (PyCFunction)THPVariable_all, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"allclose", (PyCFunction)THPVariable_allclose, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"any", (PyCFunction)THPVariable_any, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"arange", (PyCFunction)THPVariable_arange, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"as_strided", (PyCFunction)THPVariable_as_strided, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"as_strided_", (PyCFunction)THPVariable_as_strided_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"asin", (PyCFunction)THPVariable_asin, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"asin_", (PyCFunction)THPVariable_asin_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"atan", (PyCFunction)THPVariable_atan, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"atan2", (PyCFunction)THPVariable_atan2, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"atan2_", (PyCFunction)THPVariable_atan2_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"atan_", (PyCFunction)THPVariable_atan_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"baddbmm", (PyCFunction)THPVariable_baddbmm, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"baddbmm_", (PyCFunction)THPVariable_baddbmm_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"batch_norm", (PyCFunction)THPVariable_batch_norm, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"bernoulli", (PyCFunction)THPVariable_bernoulli, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"bernoulli_", (PyCFunction)THPVariable_bernoulli_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"bmm", (PyCFunction)THPVariable_bmm, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"btrifact", (PyCFunction)THPVariable_btrifact, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"btrifact_with_info", (PyCFunction)THPVariable_btrifact_with_info, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"btrisolve", (PyCFunction)THPVariable_btrisolve, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"cat", (PyCFunction)THPVariable_cat, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"cauchy_", (PyCFunction)THPVariable_cauchy_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"ceil", (PyCFunction)THPVariable_ceil, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"ceil_", (PyCFunction)THPVariable_ceil_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"chunk", (PyCFunction)THPVariable_chunk, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"clone", (PyCFunction)THPVariable_clone, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"conv1d", (PyCFunction)THPVariable_conv1d, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"conv2d", (PyCFunction)THPVariable_conv2d, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"conv3d", (PyCFunction)THPVariable_conv3d, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"conv_tbc", (PyCFunction)THPVariable_conv_tbc, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"conv_transpose1d", (PyCFunction)THPVariable_conv_transpose1d, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"conv_transpose2d", (PyCFunction)THPVariable_conv_transpose2d, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"conv_transpose3d", (PyCFunction)THPVariable_conv_transpose3d, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"convolution", (PyCFunction)THPVariable_convolution, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"cos", (PyCFunction)THPVariable_cos, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"cos_", (PyCFunction)THPVariable_cos_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"cosh", (PyCFunction)THPVariable_cosh, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"cosh_", (PyCFunction)THPVariable_cosh_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"cross", (PyCFunction)THPVariable_cross, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"cudnn_affine_grid_generator", (PyCFunction)THPVariable_cudnn_affine_grid_generator, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"cudnn_batch_norm", (PyCFunction)THPVariable_cudnn_batch_norm, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"cudnn_convolution", (PyCFunction)THPVariable_cudnn_convolution, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"cudnn_convolution_backward_bias", (PyCFunction)THPVariable_cudnn_convolution_backward_bias, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"cudnn_convolution_backward_input", (PyCFunction)THPVariable_cudnn_convolution_backward_input, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"cudnn_convolution_backward_weight", (PyCFunction)THPVariable_cudnn_convolution_backward_weight, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"cudnn_convolution_transpose", (PyCFunction)THPVariable_cudnn_convolution_transpose, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"cudnn_convolution_transpose_backward_bias", (PyCFunction)THPVariable_cudnn_convolution_transpose_backward_bias, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"cudnn_convolution_transpose_backward_input", (PyCFunction)THPVariable_cudnn_convolution_transpose_backward_input, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"cudnn_convolution_transpose_backward_weight", (PyCFunction)THPVariable_cudnn_convolution_transpose_backward_weight, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"cudnn_grid_sampler", (PyCFunction)THPVariable_cudnn_grid_sampler, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"cumprod", (PyCFunction)THPVariable_cumprod, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"cumsum", (PyCFunction)THPVariable_cumsum, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"data_ptr", (PyCFunction)THPVariable_data_ptr, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"det", (PyCFunction)THPVariable_det, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"diag", (PyCFunction)THPVariable_diag, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"digamma", (PyCFunction)THPVariable_digamma, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"digamma_", (PyCFunction)THPVariable_digamma_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"dist", (PyCFunction)THPVariable_dist, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"div", (PyCFunction)THPVariable_div, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"div_", (PyCFunction)THPVariable_div_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"dot", (PyCFunction)THPVariable_dot, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"eig", (PyCFunction)THPVariable_eig, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"embedding", (PyCFunction)THPVariable_embedding, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"embedding_renorm_", (PyCFunction)THPVariable_embedding_renorm_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"eq", (PyCFunction)THPVariable_eq, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"eq_", (PyCFunction)THPVariable_eq_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"equal", (PyCFunction)THPVariable_equal, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"erf", (PyCFunction)THPVariable_erf, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"erf_", (PyCFunction)THPVariable_erf_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"erfinv", (PyCFunction)THPVariable_erfinv, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"erfinv_", (PyCFunction)THPVariable_erfinv_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"exp", (PyCFunction)THPVariable_exp, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"exp_", (PyCFunction)THPVariable_exp_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"expand", (PyCFunction)THPVariable_expand, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"expand_as", (PyCFunction)THPVariable_expand_as, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"expm1", (PyCFunction)THPVariable_expm1, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"expm1_", (PyCFunction)THPVariable_expm1_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"exponential_", (PyCFunction)THPVariable_exponential_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"eye", (PyCFunction)THPVariable_eye, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"fill_", (PyCFunction)THPVariable_fill_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"floor", (PyCFunction)THPVariable_floor, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"floor_", (PyCFunction)THPVariable_floor_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"fmod", (PyCFunction)THPVariable_fmod, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"fmod_", (PyCFunction)THPVariable_fmod_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"frac", (PyCFunction)THPVariable_frac, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"frac_", (PyCFunction)THPVariable_frac_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"gather", (PyCFunction)THPVariable_gather, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"ge", (PyCFunction)THPVariable_ge, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"ge_", (PyCFunction)THPVariable_ge_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"gels", (PyCFunction)THPVariable_gels, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"geometric_", (PyCFunction)THPVariable_geometric_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"geqrf", (PyCFunction)THPVariable_geqrf, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"ger", (PyCFunction)THPVariable_ger, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"gesv", (PyCFunction)THPVariable_gesv, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"get_device", (PyCFunction)THPVariable_get_device, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"gt", (PyCFunction)THPVariable_gt, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"gt_", (PyCFunction)THPVariable_gt_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"histc", (PyCFunction)THPVariable_histc, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"index", (PyCFunction)THPVariable_index, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"index_add_", (PyCFunction)THPVariable_index_add_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"index_copy_", (PyCFunction)THPVariable_index_copy_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"index_fill_", (PyCFunction)THPVariable_index_fill_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"index_put_", (PyCFunction)THPVariable_index_put_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"index_select", (PyCFunction)THPVariable_index_select, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"inverse", (PyCFunction)THPVariable_inverse, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"is_contiguous", (PyCFunction)THPVariable_is_contiguous, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"is_distributed", (PyCFunction)THPVariable_is_distributed, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"is_nonzero", (PyCFunction)THPVariable_is_nonzero, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"is_same_size", (PyCFunction)THPVariable_is_same_size, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"is_set_to", (PyCFunction)THPVariable_is_set_to, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"is_signed", (PyCFunction)THPVariable_is_signed, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"kthvalue", (PyCFunction)THPVariable_kthvalue, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"le", (PyCFunction)THPVariable_le, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"le_", (PyCFunction)THPVariable_le_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"lerp", (PyCFunction)THPVariable_lerp, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"lerp_", (PyCFunction)THPVariable_lerp_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"lgamma", (PyCFunction)THPVariable_lgamma, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"lgamma_", (PyCFunction)THPVariable_lgamma_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"linspace", (PyCFunction)THPVariable_linspace, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"log", (PyCFunction)THPVariable_log, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"log1p", (PyCFunction)THPVariable_log1p, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"log1p_", (PyCFunction)THPVariable_log1p_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"log_", (PyCFunction)THPVariable_log_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"log_normal_", (PyCFunction)THPVariable_log_normal_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"logspace", (PyCFunction)THPVariable_logspace, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"lt", (PyCFunction)THPVariable_lt, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"lt_", (PyCFunction)THPVariable_lt_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"masked_fill_", (PyCFunction)THPVariable_masked_fill_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"masked_scatter_", (PyCFunction)THPVariable_masked_scatter_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"masked_select", (PyCFunction)THPVariable_masked_select, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"matmul", (PyCFunction)THPVariable_matmul, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"max", (PyCFunction)THPVariable_max, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"max_pool1d", (PyCFunction)THPVariable_max_pool1d, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"mean", (PyCFunction)THPVariable_mean, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"median", (PyCFunction)THPVariable_median, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"min", (PyCFunction)THPVariable_min, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"mm", (PyCFunction)THPVariable_mm, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"mode", (PyCFunction)THPVariable_mode, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"mul", (PyCFunction)THPVariable_mul, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"mul_", (PyCFunction)THPVariable_mul_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"multinomial", (PyCFunction)THPVariable_multinomial, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"mv", (PyCFunction)THPVariable_mv, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"narrow", (PyCFunction)THPVariable_narrow, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"ne", (PyCFunction)THPVariable_ne, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"ne_", (PyCFunction)THPVariable_ne_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"neg", (PyCFunction)THPVariable_neg, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"neg_", (PyCFunction)THPVariable_neg_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"nnpack_spatial_convolution", (PyCFunction)THPVariable_nnpack_spatial_convolution, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"nnpack_spatial_convolution_backward_input", (PyCFunction)THPVariable_nnpack_spatial_convolution_backward_input, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"nnpack_spatial_convolution_backward_weight", (PyCFunction)THPVariable_nnpack_spatial_convolution_backward_weight, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"nonzero", (PyCFunction)THPVariable_nonzero, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"norm", (PyCFunction)THPVariable_norm, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"normal", (PyCFunction)THPVariable_normal, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"normal_", (PyCFunction)THPVariable_normal_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"numel", (PyCFunction)THPVariable_numel, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"ones", (PyCFunction)THPVariable_ones, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"ones_like", (PyCFunction)THPVariable_ones_like, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"orgqr", (PyCFunction)THPVariable_orgqr, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"ormqr", (PyCFunction)THPVariable_ormqr, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"permute", (PyCFunction)THPVariable_permute, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"pin_memory", (PyCFunction)THPVariable_pin_memory, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"polygamma", (PyCFunction)THPVariable_polygamma, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"polygamma_", (PyCFunction)THPVariable_polygamma_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"potrf", (PyCFunction)THPVariable_potrf, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"potri", (PyCFunction)THPVariable_potri, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"potrs", (PyCFunction)THPVariable_potrs, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"pow", (PyCFunction)THPVariable_pow, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"pow_", (PyCFunction)THPVariable_pow_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"prod", (PyCFunction)THPVariable_prod, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"pstrf", (PyCFunction)THPVariable_pstrf, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"put_", (PyCFunction)THPVariable_put_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"qr", (PyCFunction)THPVariable_qr, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"rand", (PyCFunction)THPVariable_rand, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"randn", (PyCFunction)THPVariable_randn, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"random_", (PyCFunction)THPVariable_random_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"randperm", (PyCFunction)THPVariable_randperm, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"range", (PyCFunction)THPVariable_range, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"reciprocal", (PyCFunction)THPVariable_reciprocal, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"reciprocal_", (PyCFunction)THPVariable_reciprocal_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"remainder", (PyCFunction)THPVariable_remainder, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"remainder_", (PyCFunction)THPVariable_remainder_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"renorm", (PyCFunction)THPVariable_renorm, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"renorm_", (PyCFunction)THPVariable_renorm_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"reshape_", (PyCFunction)THPVariable_reshape_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"resize_", (PyCFunction)THPVariable_resize_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"resize_as_", (PyCFunction)THPVariable_resize_as_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"round", (PyCFunction)THPVariable_round, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"round_", (PyCFunction)THPVariable_round_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"rrelu", (PyCFunction)THPVariable_rrelu, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"rrelu_", (PyCFunction)THPVariable_rrelu_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"rsqrt", (PyCFunction)THPVariable_rsqrt, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"rsqrt_", (PyCFunction)THPVariable_rsqrt_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"scatter_", (PyCFunction)THPVariable_scatter_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"scatter_add_", (PyCFunction)THPVariable_scatter_add_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"select", (PyCFunction)THPVariable_select, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"selu", (PyCFunction)THPVariable_selu, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"selu_", (PyCFunction)THPVariable_selu_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"set_", (PyCFunction)THPVariable_set_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"sigmoid", (PyCFunction)THPVariable_sigmoid, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"sigmoid_", (PyCFunction)THPVariable_sigmoid_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"sign", (PyCFunction)THPVariable_sign, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"sign_", (PyCFunction)THPVariable_sign_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"sin", (PyCFunction)THPVariable_sin, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"sin_", (PyCFunction)THPVariable_sin_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"sinh", (PyCFunction)THPVariable_sinh, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"sinh_", (PyCFunction)THPVariable_sinh_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"slice", (PyCFunction)THPVariable_slice, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"sort", (PyCFunction)THPVariable_sort, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"sparse_coo_tensor", (PyCFunction)THPVariable_sparse_coo_tensor, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"split", (PyCFunction)THPVariable_split, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"sqrt", (PyCFunction)THPVariable_sqrt, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"sqrt_", (PyCFunction)THPVariable_sqrt_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"squeeze", (PyCFunction)THPVariable_squeeze, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"squeeze_", (PyCFunction)THPVariable_squeeze_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"stack", (PyCFunction)THPVariable_stack, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"std", (PyCFunction)THPVariable_std, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"stft", (PyCFunction)THPVariable_stft, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"storage_offset", (PyCFunction)THPVariable_storage_offset, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"sub", (PyCFunction)THPVariable_sub, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"sub_", (PyCFunction)THPVariable_sub_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"sum", (PyCFunction)THPVariable_sum, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"svd", (PyCFunction)THPVariable_svd, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"symeig", (PyCFunction)THPVariable_symeig, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"t", (PyCFunction)THPVariable_t, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"t_", (PyCFunction)THPVariable_t_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"take", (PyCFunction)THPVariable_take, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"tan", (PyCFunction)THPVariable_tan, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"tan_", (PyCFunction)THPVariable_tan_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"tanh", (PyCFunction)THPVariable_tanh, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"tanh_", (PyCFunction)THPVariable_tanh_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"tensor", (PyCFunction)THPVariable_tensor, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"topk", (PyCFunction)THPVariable_topk, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"trace", (PyCFunction)THPVariable_trace, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"transpose", (PyCFunction)THPVariable_transpose, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"transpose_", (PyCFunction)THPVariable_transpose_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"tril", (PyCFunction)THPVariable_tril, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"tril_", (PyCFunction)THPVariable_tril_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"triu", (PyCFunction)THPVariable_triu, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"triu_", (PyCFunction)THPVariable_triu_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"trtrs", (PyCFunction)THPVariable_trtrs, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"trunc", (PyCFunction)THPVariable_trunc, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"trunc_", (PyCFunction)THPVariable_trunc_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"type_as", (PyCFunction)THPVariable_type_as, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"unfold", (PyCFunction)THPVariable_unfold, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"uniform_", (PyCFunction)THPVariable_uniform_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"unsqueeze", (PyCFunction)THPVariable_unsqueeze, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"unsqueeze_", (PyCFunction)THPVariable_unsqueeze_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"var", (PyCFunction)THPVariable_var, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"view", (PyCFunction)THPVariable_view, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"view_as", (PyCFunction)THPVariable_view_as, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"where", (PyCFunction)THPVariable_where, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"zero_", (PyCFunction)THPVariable_zero_, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"zeros", (PyCFunction)THPVariable_zeros, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {"zeros_like", (PyCFunction)THPVariable_zeros_like, METH_VARARGS | METH_KEYWORDS | METH_STATIC, NULL},
  {NULL}
};

static PyTypeObject THPVariableFunctions = {
  PyVarObject_HEAD_INIT(NULL, 0)
  "torch._C._VariableFunctions",         /* tp_name */
  0,                                     /* tp_basicsize */
  0,                                     /* tp_itemsize */
  0,                                     /* tp_dealloc */
  0,                                     /* tp_print */
  0,                                     /* tp_getattr */
  0,                                     /* tp_setattr */
  0,                                     /* tp_reserved */
  0,                                     /* tp_repr */
  0,                                     /* tp_as_number */
  0,                                     /* tp_as_sequence */
  0,                                     /* tp_as_mapping */
  0,                                     /* tp_hash  */
  0,                                     /* tp_call */
  0,                                     /* tp_str */
  0,                                     /* tp_getattro */
  0,                                     /* tp_setattro */
  0,                                     /* tp_as_buffer */
  Py_TPFLAGS_DEFAULT,                    /* tp_flags */
  NULL,                                  /* tp_doc */
  0,                                     /* tp_traverse */
  0,                                     /* tp_clear */
  0,                                     /* tp_richcompare */
  0,                                     /* tp_weaklistoffset */
  0,                                     /* tp_iter */
  0,                                     /* tp_iternext */
  torch_functions,                       /* tp_methods */
  0,                                     /* tp_members */
  0,                                     /* tp_getset */
  0,                                     /* tp_base */
  0,                                     /* tp_dict */
  0,                                     /* tp_descr_get */
  0,                                     /* tp_descr_set */
  0,                                     /* tp_dictoffset */
  0,                                     /* tp_init */
  0,                                     /* tp_alloc */
  0                                      /* tp_new */
};

void initTorchFunctions(PyObject* module) {
  if (PyType_Ready(&THPVariableFunctions) < 0) {
    throw python_error();
  }
  Py_INCREF(&THPVariableFunctions);
  if (PyModule_AddObject(module, "_VariableFunctions", (PyObject*)&THPVariableFunctions) < 0) {
    throw python_error();
  }
}

}} // namespace torch::autograd