#include "torch/csrc/autograd/FunctionsManual.h"
#include "torch/csrc/dynamo/compiled_autograd.h"

// @generated from ../tools/autograd/templates/Functions.cpp

// The manual function definitions that used to be here are now in torch/csrc/autograd/FunctionsManual.cpp
// This speeds up re-compilation and allow to share these implementations so that they can be
// used for forward mode AD formulas as well.

using namespace torch::autograd::generated::details;
using at::Tensor;
using at::Scalar;
using at::IntArrayRef;
using at::TensorList;

namespace torch::autograd::generated {

static at::IValue compute_output_metadata(const torch::autograd::edge_list& next_edges) {
  auto output_metadata = torch::dynamo::autograd::IValuePacker<
      std::vector<std::optional<InputMetadata>>>::pack(
              torch::dynamo::autograd::get_input_metadata(next_edges));
  return output_metadata;
}

static C10_NOINLINE variable_list compiled_autograd_apply_functional(
    const PackedArgs& packed_args,
    const edge_list& next_edges,
    SwapSavedVariables& saved,
    const variable_list& grads,
    const std::string& name) {
  auto output_metadata = compute_output_metadata(next_edges);
  const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
  return pyinterface->call_function(
      saved.get_py_compiler(),
      "apply_functional",
      name,
      grads,
      packed_args.vec(),
      output_metadata);
}

static variable_list AbsBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad * self.sgn()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list AbsBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  return AbsBackward0_apply_functional(variable_list(grads), needs_input_grad, self);
#endif
}

variable_list AbsBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return AbsBackward0_apply_functional(std::move(grads), needs_input_grad, self);
}

void AbsBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list AbsBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), AbsBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list AcosBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad * -((-self * self + 1).rsqrt()).conj()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list AcosBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  return AcosBackward0_apply_functional(variable_list(grads), needs_input_grad, self);
#endif
}

variable_list AcosBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return AcosBackward0_apply_functional(std::move(grads), needs_input_grad, self);
}

void AcosBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list AcosBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), AcosBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list AddBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, at::Scalar& alpha, at::ScalarType& other_scalar_type, at::ScalarType& self_scalar_type)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*other*/1]) {
    auto grad_result = any_grad_defined ? (handle_r_to_c(other_scalar_type, maybe_multiply(grad, alpha.conj()))) : Tensor();
    copy_range(grad_inputs, other_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (handle_r_to_c(self_scalar_type, grad)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list AddBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto alpha = packed_args.unpack<at::Scalar>();
  auto other_scalar_type = packed_args.unpack<at::ScalarType>();
  auto self_scalar_type = packed_args.unpack<at::ScalarType>();
  return AddBackward0_apply_functional(variable_list(grads), needs_input_grad, alpha, other_scalar_type, self_scalar_type);
#endif
}

variable_list AddBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  return AddBackward0_apply_functional(std::move(grads), needs_input_grad, alpha, other_scalar_type, self_scalar_type);
}

void AddBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(alpha);
    args.collect(other_scalar_type);
    args.collect(self_scalar_type);
}
variable_list AddBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(alpha);
  saved.before(other_scalar_type);
  saved.before(self_scalar_type);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::ScalarType>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::ScalarType>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), AddBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(alpha);
  packed_args.pack(other_scalar_type);
  packed_args.pack(self_scalar_type);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(alpha);
  saved.after(other_scalar_type);
  saved.after(self_scalar_type);
  return output_result;
#endif
}

static variable_list AddBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, at::ScalarType& self_scalar_type)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (handle_r_to_c(self_scalar_type, grad)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list AddBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_scalar_type = packed_args.unpack<at::ScalarType>();
  return AddBackward1_apply_functional(variable_list(grads), needs_input_grad, self_scalar_type);
#endif
}

variable_list AddBackward1::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return AddBackward1_apply_functional(std::move(grads), needs_input_grad, self_scalar_type);
}

void AddBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_scalar_type);
}
variable_list AddBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_scalar_type);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::ScalarType>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), AddBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_scalar_type);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_scalar_type);
  return output_result;
#endif
}

static variable_list AddbmmBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, at::Scalar& alpha, Tensor& batch1, c10::SymInt& batch1_sym_argsize_0, c10::SymInt& batch1_sym_argsize_1, Tensor& batch2, c10::SymInt& batch2_sym_argsize_2, at::Scalar& beta)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto batch1_ix = gen.range(1);
  auto batch2_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*batch1*/1]) {
    auto grad_result = any_grad_defined ? (maybe_multiply(grad.unsqueeze(0).expand_symint({ batch1_sym_argsize_0, batch1_sym_argsize_1, batch2_sym_argsize_2 }).bmm(batch2.transpose(1, 2).conj()), alpha.conj())) : Tensor();
    copy_range(grad_inputs, batch1_ix, grad_result);
  }
  if (needs_input_grad[/*batch2*/2]) {
    auto grad_result = any_grad_defined ? (maybe_multiply(batch1.transpose(1, 2).conj().bmm(grad.unsqueeze(0).expand_symint({ batch1_sym_argsize_0, batch1_sym_argsize_1, batch2_sym_argsize_2 })), alpha.conj())) : Tensor();
    copy_range(grad_inputs, batch2_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (maybe_multiply(grad, beta.conj())) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list AddbmmBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto alpha = packed_args.unpack<at::Scalar>();
  auto batch1 = packed_args.unpack<Tensor>();
  auto batch1_sym_argsize_0 = packed_args.unpack<c10::SymInt>();
  auto batch1_sym_argsize_1 = packed_args.unpack<c10::SymInt>();
  auto batch2 = packed_args.unpack<Tensor>();
  auto batch2_sym_argsize_2 = packed_args.unpack<c10::SymInt>();
  auto beta = packed_args.unpack<at::Scalar>();
  return AddbmmBackward0_apply_functional(variable_list(grads), needs_input_grad, alpha, batch1, batch1_sym_argsize_0, batch1_sym_argsize_1, batch2, batch2_sym_argsize_2, beta);
#endif
}

variable_list AddbmmBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto batch1 = batch1_.unpack();
  auto batch2 = batch2_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto batch1_ix = gen.range(1);
  auto batch2_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ batch1_ix }),
    task_should_compute_output({ batch2_ix }),
  };
  return AddbmmBackward0_apply_functional(std::move(grads), needs_input_grad, alpha, batch1, batch1_sym_argsize_0, batch1_sym_argsize_1, batch2, batch2_sym_argsize_2, beta);
}

void AddbmmBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(alpha);
    args.collect(batch1_, false);
    args.collect(batch1_sym_argsize_0);
    args.collect(batch1_sym_argsize_1);
    args.collect(batch2_, false);
    args.collect(batch2_sym_argsize_2);
    args.collect(beta);
}
variable_list AddbmmBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(alpha);
  saved.before(batch1_);
  saved.before(batch1_sym_argsize_0);
  saved.before(batch1_sym_argsize_1);
  saved.before(batch2_);
  saved.before(batch2_sym_argsize_2);
  saved.before(beta);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), AddbmmBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto batch1 = batch1_.unpack();
  auto batch2 = batch2_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto batch1_ix = gen.range(1);
  auto batch2_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ batch1_ix }),
    task_should_compute_output({ batch2_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(alpha);
  packed_args.pack(batch1);
  packed_args.pack(batch1_sym_argsize_0);
  packed_args.pack(batch1_sym_argsize_1);
  packed_args.pack(batch2);
  packed_args.pack(batch2_sym_argsize_2);
  packed_args.pack(beta);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(alpha);
  saved.after(batch1_);
  saved.after(batch1_sym_argsize_0);
  saved.after(batch1_sym_argsize_1);
  saved.after(batch2_);
  saved.after(batch2_sym_argsize_2);
  saved.after(beta);
  return output_result;
#endif
}

static variable_list AddcdivBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, at::ScalarType& self_scalar_type, Tensor& tensor1, at::ScalarType& tensor1_scalar_type, Tensor& tensor2, at::ScalarType& tensor2_scalar_type, at::Scalar& value)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto tensor1_ix = gen.range(1);
  auto tensor2_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (handle_r_to_c(self_scalar_type, grad)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  if (needs_input_grad[/*tensor1*/1]) {
    auto grad_result = any_grad_defined ? (handle_r_to_c(tensor1_scalar_type, grad * (value / tensor2).conj())) : Tensor();
    copy_range(grad_inputs, tensor1_ix, grad_result);
  }
  if (needs_input_grad[/*tensor2*/2]) {
    auto grad_result = any_grad_defined ? (handle_r_to_c(tensor2_scalar_type, -grad * (value * tensor1 / (tensor2 * tensor2)).conj())) : Tensor();
    copy_range(grad_inputs, tensor2_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list AddcdivBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto self_scalar_type = packed_args.unpack<at::ScalarType>();
  auto tensor1 = packed_args.unpack<Tensor>();
  auto tensor1_scalar_type = packed_args.unpack<at::ScalarType>();
  auto tensor2 = packed_args.unpack<Tensor>();
  auto tensor2_scalar_type = packed_args.unpack<at::ScalarType>();
  auto value = packed_args.unpack<at::Scalar>();
  return AddcdivBackward0_apply_functional(variable_list(grads), needs_input_grad, self_scalar_type, tensor1, tensor1_scalar_type, tensor2, tensor2_scalar_type, value);
#endif
}

variable_list AddcdivBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto tensor1 = tensor1_.unpack();
  auto tensor2 = tensor2_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto tensor1_ix = gen.range(1);
  auto tensor2_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ tensor1_ix }),
    task_should_compute_output({ tensor2_ix }),
  };
  return AddcdivBackward0_apply_functional(std::move(grads), needs_input_grad, self_scalar_type, tensor1, tensor1_scalar_type, tensor2, tensor2_scalar_type, value);
}

void AddcdivBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_scalar_type);
    args.collect(tensor1_, false);
    args.collect(tensor1_scalar_type);
    args.collect(tensor2_, false);
    args.collect(tensor2_scalar_type);
    args.collect(value);
}
variable_list AddcdivBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_scalar_type);
  saved.before(tensor1_);
  saved.before(tensor1_scalar_type);
  saved.before(tensor2_);
  saved.before(tensor2_scalar_type);
  saved.before(value);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::ScalarType>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::ScalarType>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::ScalarType>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), AddcdivBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto tensor1 = tensor1_.unpack();
  auto tensor2 = tensor2_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto tensor1_ix = gen.range(1);
  auto tensor2_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ tensor1_ix }),
    task_should_compute_output({ tensor2_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_scalar_type);
  packed_args.pack(tensor1);
  packed_args.pack(tensor1_scalar_type);
  packed_args.pack(tensor2);
  packed_args.pack(tensor2_scalar_type);
  packed_args.pack(value);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_scalar_type);
  saved.after(tensor1_);
  saved.after(tensor1_scalar_type);
  saved.after(tensor2_);
  saved.after(tensor2_scalar_type);
  saved.after(value);
  return output_result;
#endif
}

static variable_list AddcmulBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, at::ScalarType& self_scalar_type, Tensor& tensor1, at::ScalarType& tensor1_scalar_type, Tensor& tensor2, at::ScalarType& tensor2_scalar_type, at::Scalar& value)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto tensor1_ix = gen.range(1);
  auto tensor2_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (handle_r_to_c(self_scalar_type, grad)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  if (needs_input_grad[/*tensor1*/1]) {
    auto grad_result = any_grad_defined ? (handle_r_to_c(tensor1_scalar_type, grad * (tensor2 * value).conj())) : Tensor();
    copy_range(grad_inputs, tensor1_ix, grad_result);
  }
  if (needs_input_grad[/*tensor2*/2]) {
    auto grad_result = any_grad_defined ? (handle_r_to_c(tensor2_scalar_type, grad * (tensor1 * value).conj())) : Tensor();
    copy_range(grad_inputs, tensor2_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list AddcmulBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto self_scalar_type = packed_args.unpack<at::ScalarType>();
  auto tensor1 = packed_args.unpack<Tensor>();
  auto tensor1_scalar_type = packed_args.unpack<at::ScalarType>();
  auto tensor2 = packed_args.unpack<Tensor>();
  auto tensor2_scalar_type = packed_args.unpack<at::ScalarType>();
  auto value = packed_args.unpack<at::Scalar>();
  return AddcmulBackward0_apply_functional(variable_list(grads), needs_input_grad, self_scalar_type, tensor1, tensor1_scalar_type, tensor2, tensor2_scalar_type, value);
#endif
}

variable_list AddcmulBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto tensor1 = tensor1_.unpack();
  auto tensor2 = tensor2_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto tensor1_ix = gen.range(1);
  auto tensor2_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ tensor1_ix }),
    task_should_compute_output({ tensor2_ix }),
  };
  return AddcmulBackward0_apply_functional(std::move(grads), needs_input_grad, self_scalar_type, tensor1, tensor1_scalar_type, tensor2, tensor2_scalar_type, value);
}

void AddcmulBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_scalar_type);
    args.collect(tensor1_, false);
    args.collect(tensor1_scalar_type);
    args.collect(tensor2_, false);
    args.collect(tensor2_scalar_type);
    args.collect(value);
}
variable_list AddcmulBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_scalar_type);
  saved.before(tensor1_);
  saved.before(tensor1_scalar_type);
  saved.before(tensor2_);
  saved.before(tensor2_scalar_type);
  saved.before(value);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::ScalarType>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::ScalarType>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::ScalarType>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), AddcmulBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto tensor1 = tensor1_.unpack();
  auto tensor2 = tensor2_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto tensor1_ix = gen.range(1);
  auto tensor2_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ tensor1_ix }),
    task_should_compute_output({ tensor2_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_scalar_type);
  packed_args.pack(tensor1);
  packed_args.pack(tensor1_scalar_type);
  packed_args.pack(tensor2);
  packed_args.pack(tensor2_scalar_type);
  packed_args.pack(value);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_scalar_type);
  saved.after(tensor1_);
  saved.after(tensor1_scalar_type);
  saved.after(tensor2_);
  saved.after(tensor2_scalar_type);
  saved.after(value);
  return output_result;
#endif
}

static variable_list AddmmBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, at::Scalar& alpha, at::Scalar& beta, Tensor& mat1, at::Layout& mat1_layout, std::vector<c10::SymInt>& mat1_sym_sizes, std::vector<c10::SymInt>& mat1_sym_strides, Tensor& mat2, at::Layout& mat2_layout, std::vector<c10::SymInt>& mat2_sym_sizes, std::vector<c10::SymInt>& mat2_sym_strides)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto mat1_ix = gen.range(1);
  auto mat2_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*mat1*/1]) {
    auto grad_result = any_grad_defined ? (mm_mat1_backward(grad, mat2, mat1_sym_sizes, mat1_sym_strides, mat1_layout, alpha)) : Tensor();
    copy_range(grad_inputs, mat1_ix, grad_result);
  }
  if (needs_input_grad[/*mat2*/2]) {
    auto grad_result = any_grad_defined ? (mm_mat2_backward(grad, mat1, mat2_sym_sizes, mat2_sym_strides, mat2_layout, alpha)) : Tensor();
    copy_range(grad_inputs, mat2_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (maybe_multiply(grad, beta.conj())) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list AddmmBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto alpha = packed_args.unpack<at::Scalar>();
  auto beta = packed_args.unpack<at::Scalar>();
  auto mat1 = packed_args.unpack<Tensor>();
  auto mat1_layout = packed_args.unpack<at::Layout>();
  auto mat1_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  auto mat1_sym_strides = packed_args.unpack<std::vector<c10::SymInt>>();
  auto mat2 = packed_args.unpack<Tensor>();
  auto mat2_layout = packed_args.unpack<at::Layout>();
  auto mat2_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  auto mat2_sym_strides = packed_args.unpack<std::vector<c10::SymInt>>();
  return AddmmBackward0_apply_functional(variable_list(grads), needs_input_grad, alpha, beta, mat1, mat1_layout, mat1_sym_sizes, mat1_sym_strides, mat2, mat2_layout, mat2_sym_sizes, mat2_sym_strides);
#endif
}

variable_list AddmmBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto mat1 = mat1_.unpack();
  auto mat2 = mat2_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto mat1_ix = gen.range(1);
  auto mat2_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ mat1_ix }),
    task_should_compute_output({ mat2_ix }),
  };
  return AddmmBackward0_apply_functional(std::move(grads), needs_input_grad, alpha, beta, mat1, mat1_layout, mat1_sym_sizes, mat1_sym_strides, mat2, mat2_layout, mat2_sym_sizes, mat2_sym_strides);
}

void AddmmBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(alpha);
    args.collect(beta);
    args.collect(mat1_, false);
    args.collect(mat1_layout);
    args.collect(mat1_sym_sizes);
    args.collect(mat1_sym_strides);
    args.collect(mat2_, false);
    args.collect(mat2_layout);
    args.collect(mat2_sym_sizes);
    args.collect(mat2_sym_strides);
}
variable_list AddmmBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(alpha);
  saved.before(beta);
  saved.before(mat1_);
  saved.before(mat1_layout);
  saved.before(mat1_sym_sizes);
  saved.before(mat1_sym_strides);
  saved.before(mat2_);
  saved.before(mat2_layout);
  saved.before(mat2_sym_sizes);
  saved.before(mat2_sym_strides);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Layout>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Layout>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), AddmmBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto mat1 = mat1_.unpack();
  auto mat2 = mat2_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto mat1_ix = gen.range(1);
  auto mat2_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ mat1_ix }),
    task_should_compute_output({ mat2_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(alpha);
  packed_args.pack(beta);
  packed_args.pack(mat1);
  packed_args.pack(mat1_layout);
  packed_args.pack(mat1_sym_sizes);
  packed_args.pack(mat1_sym_strides);
  packed_args.pack(mat2);
  packed_args.pack(mat2_layout);
  packed_args.pack(mat2_sym_sizes);
  packed_args.pack(mat2_sym_strides);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(alpha);
  saved.after(beta);
  saved.after(mat1_);
  saved.after(mat1_layout);
  saved.after(mat1_sym_sizes);
  saved.after(mat1_sym_strides);
  saved.after(mat2_);
  saved.after(mat2_layout);
  saved.after(mat2_sym_sizes);
  saved.after(mat2_sym_strides);
  return output_result;
#endif
}

static variable_list SparseAddmmBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, at::Scalar& alpha, at::Scalar& beta, Tensor& mat1, Tensor& mat2, at::Layout& mat2_layout, std::vector<c10::SymInt>& mat2_sym_sizes, std::vector<c10::SymInt>& mat2_sym_strides)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto mat1_ix = gen.range(1);
  auto mat2_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*mat1*/1]) {
    auto grad_result = any_grad_defined ? (mm_mat1_sparse_backward(grad, mat1, mat2, alpha)) : Tensor();
    copy_range(grad_inputs, mat1_ix, grad_result);
  }
  if (needs_input_grad[/*mat2*/2]) {
    auto grad_result = any_grad_defined ? (mm_mat2_backward(grad, mat1, mat2_sym_sizes, mat2_sym_strides, mat2_layout, alpha)) : Tensor();
    copy_range(grad_inputs, mat2_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (maybe_multiply(grad, beta)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SparseAddmmBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto alpha = packed_args.unpack<at::Scalar>();
  auto beta = packed_args.unpack<at::Scalar>();
  auto mat1 = packed_args.unpack<Tensor>();
  auto mat2 = packed_args.unpack<Tensor>();
  auto mat2_layout = packed_args.unpack<at::Layout>();
  auto mat2_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  auto mat2_sym_strides = packed_args.unpack<std::vector<c10::SymInt>>();
  return SparseAddmmBackward0_apply_functional(variable_list(grads), needs_input_grad, alpha, beta, mat1, mat2, mat2_layout, mat2_sym_sizes, mat2_sym_strides);
#endif
}

variable_list SparseAddmmBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto mat1 = mat1_.unpack();
  auto mat2 = mat2_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto mat1_ix = gen.range(1);
  auto mat2_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ mat1_ix }),
    task_should_compute_output({ mat2_ix }),
  };
  return SparseAddmmBackward0_apply_functional(std::move(grads), needs_input_grad, alpha, beta, mat1, mat2, mat2_layout, mat2_sym_sizes, mat2_sym_strides);
}

void SparseAddmmBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(alpha);
    args.collect(beta);
    args.collect(mat1_, false);
    args.collect(mat2_, false);
    args.collect(mat2_layout);
    args.collect(mat2_sym_sizes);
    args.collect(mat2_sym_strides);
}
variable_list SparseAddmmBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(alpha);
  saved.before(beta);
  saved.before(mat1_);
  saved.before(mat2_);
  saved.before(mat2_layout);
  saved.before(mat2_sym_sizes);
  saved.before(mat2_sym_strides);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Layout>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SparseAddmmBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto mat1 = mat1_.unpack();
  auto mat2 = mat2_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto mat1_ix = gen.range(1);
  auto mat2_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ mat1_ix }),
    task_should_compute_output({ mat2_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(alpha);
  packed_args.pack(beta);
  packed_args.pack(mat1);
  packed_args.pack(mat2);
  packed_args.pack(mat2_layout);
  packed_args.pack(mat2_sym_sizes);
  packed_args.pack(mat2_sym_strides);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(alpha);
  saved.after(beta);
  saved.after(mat1_);
  saved.after(mat2_);
  saved.after(mat2_layout);
  saved.after(mat2_sym_sizes);
  saved.after(mat2_sym_strides);
  return output_result;
#endif
}

static variable_list AddmvBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, at::Scalar& alpha, at::Scalar& beta, Tensor& mat, Tensor& vec)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto mat_ix = gen.range(1);
  auto vec_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*mat*/1]) {
    auto grad_result = any_grad_defined ? (maybe_multiply(grad.ger(vec.conj()), alpha.conj())) : Tensor();
    copy_range(grad_inputs, mat_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (maybe_multiply(grad, beta.conj())) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  if (needs_input_grad[/*vec*/2]) {
    auto grad_result = any_grad_defined ? (maybe_multiply(mat.t().conj().mv(grad), alpha.conj())) : Tensor();
    copy_range(grad_inputs, vec_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list AddmvBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto alpha = packed_args.unpack<at::Scalar>();
  auto beta = packed_args.unpack<at::Scalar>();
  auto mat = packed_args.unpack<Tensor>();
  auto vec = packed_args.unpack<Tensor>();
  return AddmvBackward0_apply_functional(variable_list(grads), needs_input_grad, alpha, beta, mat, vec);
#endif
}

variable_list AddmvBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto mat = mat_.unpack();
  auto vec = vec_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto mat_ix = gen.range(1);
  auto vec_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ mat_ix }),
    task_should_compute_output({ vec_ix }),
  };
  return AddmvBackward0_apply_functional(std::move(grads), needs_input_grad, alpha, beta, mat, vec);
}

void AddmvBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(alpha);
    args.collect(beta);
    args.collect(mat_, false);
    args.collect(vec_, false);
}
variable_list AddmvBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(alpha);
  saved.before(beta);
  saved.before(mat_);
  saved.before(vec_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), AddmvBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto mat = mat_.unpack();
  auto vec = vec_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto mat_ix = gen.range(1);
  auto vec_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ mat_ix }),
    task_should_compute_output({ vec_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(alpha);
  packed_args.pack(beta);
  packed_args.pack(mat);
  packed_args.pack(vec);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(alpha);
  saved.after(beta);
  saved.after(mat_);
  saved.after(vec_);
  return output_result;
#endif
}

static variable_list AddrBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, at::Scalar& alpha, at::Scalar& beta, Tensor& vec1, Tensor& vec2)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto vec1_ix = gen.range(1);
  auto vec2_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (maybe_multiply(grad, beta.conj())) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  if (needs_input_grad[/*vec1*/1]) {
    auto grad_result = any_grad_defined ? (maybe_multiply(grad.mv(vec2.conj()), alpha.conj())) : Tensor();
    copy_range(grad_inputs, vec1_ix, grad_result);
  }
  if (needs_input_grad[/*vec2*/2]) {
    auto grad_result = any_grad_defined ? (maybe_multiply(grad.t().mv(vec1.conj()), alpha.conj())) : Tensor();
    copy_range(grad_inputs, vec2_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list AddrBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto alpha = packed_args.unpack<at::Scalar>();
  auto beta = packed_args.unpack<at::Scalar>();
  auto vec1 = packed_args.unpack<Tensor>();
  auto vec2 = packed_args.unpack<Tensor>();
  return AddrBackward0_apply_functional(variable_list(grads), needs_input_grad, alpha, beta, vec1, vec2);
#endif
}

variable_list AddrBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto vec1 = vec1_.unpack();
  auto vec2 = vec2_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto vec1_ix = gen.range(1);
  auto vec2_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ vec1_ix }),
    task_should_compute_output({ vec2_ix }),
  };
  return AddrBackward0_apply_functional(std::move(grads), needs_input_grad, alpha, beta, vec1, vec2);
}

void AddrBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(alpha);
    args.collect(beta);
    args.collect(vec1_, false);
    args.collect(vec2_, false);
}
variable_list AddrBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(alpha);
  saved.before(beta);
  saved.before(vec1_);
  saved.before(vec2_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), AddrBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto vec1 = vec1_.unpack();
  auto vec2 = vec2_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto vec1_ix = gen.range(1);
  auto vec2_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ vec1_ix }),
    task_should_compute_output({ vec2_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(alpha);
  packed_args.pack(beta);
  packed_args.pack(vec1);
  packed_args.pack(vec2);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(alpha);
  saved.after(beta);
  saved.after(vec1_);
  saved.after(vec2_);
  return output_result;
#endif
}

static variable_list AffineGridGeneratorBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, bool& align_corners, std::vector<c10::SymInt>& size)
{
  IndexRangeGenerator gen;
  auto theta_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*theta*/0]) {
    auto grad_result = any_grad_defined ? (affine_grid_generator_backward_symint(grad, size, align_corners)) : Tensor();
    copy_range(grad_inputs, theta_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list AffineGridGeneratorBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto align_corners = packed_args.unpack<bool>();
  auto size = packed_args.unpack<std::vector<c10::SymInt>>();
  return AffineGridGeneratorBackward0_apply_functional(variable_list(grads), needs_input_grad, align_corners, size);
#endif
}

variable_list AffineGridGeneratorBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto theta_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ theta_ix }),
  };
  return AffineGridGeneratorBackward0_apply_functional(std::move(grads), needs_input_grad, align_corners, size);
}

void AffineGridGeneratorBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(align_corners);
    args.collect(size);
}
variable_list AffineGridGeneratorBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(align_corners);
  saved.before(size);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), AffineGridGeneratorBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto theta_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ theta_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(align_corners);
  packed_args.pack(size);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(align_corners);
  saved.after(size);
  return output_result;
#endif
}

static variable_list AliasBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list AliasBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return AliasBackward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list AliasBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return AliasBackward0_apply_functional(std::move(grads), needs_input_grad);
}

void AliasBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list AliasBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), AliasBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list AngleBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (angle_backward(grad, self)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list AngleBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  return AngleBackward0_apply_functional(variable_list(grads), needs_input_grad, self);
#endif
}

variable_list AngleBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return AngleBackward0_apply_functional(std::move(grads), needs_input_grad, self);
}

void AngleBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list AngleBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), AngleBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list AcoshBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (self.is_complex() ? grad * ((self + 1).rsqrt() * (self - 1).rsqrt()).conj() : grad * (self * self - 1).rsqrt()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list AcoshBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  return AcoshBackward0_apply_functional(variable_list(grads), needs_input_grad, self);
#endif
}

variable_list AcoshBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return AcoshBackward0_apply_functional(std::move(grads), needs_input_grad, self);
}

void AcoshBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list AcoshBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), AcoshBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list AcoshBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = not_implemented("inplace version of acosh");
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list AcoshBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return AcoshBackward1_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list AcoshBackward1::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return AcoshBackward1_apply_functional(std::move(grads), needs_input_grad);
}

void AcoshBackward1::compiled_args(CompiledNodeArgs& args) const {

}
variable_list AcoshBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), AcoshBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list AsinhBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad * (self.pow(2) + 1).rsqrt().conj()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list AsinhBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  return AsinhBackward0_apply_functional(variable_list(grads), needs_input_grad, self);
#endif
}

variable_list AsinhBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return AsinhBackward0_apply_functional(std::move(grads), needs_input_grad, self);
}

void AsinhBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list AsinhBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), AsinhBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list AsinhBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = not_implemented("inplace version of asinh");
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list AsinhBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return AsinhBackward1_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list AsinhBackward1::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return AsinhBackward1_apply_functional(std::move(grads), needs_input_grad);
}

void AsinhBackward1::compiled_args(CompiledNodeArgs& args) const {

}
variable_list AsinhBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), AsinhBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list AtanhBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad * 1 / (1 - self.pow(2)).conj()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list AtanhBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  return AtanhBackward0_apply_functional(variable_list(grads), needs_input_grad, self);
#endif
}

variable_list AtanhBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return AtanhBackward0_apply_functional(std::move(grads), needs_input_grad, self);
}

void AtanhBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list AtanhBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), AtanhBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list AtanhBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = not_implemented("inplace version of atanh");
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list AtanhBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return AtanhBackward1_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list AtanhBackward1::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return AtanhBackward1_apply_functional(std::move(grads), needs_input_grad);
}

void AtanhBackward1::compiled_args(CompiledNodeArgs& args) const {

}
variable_list AtanhBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), AtanhBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list AsStridedBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, at::TensorGeometry& self_geometry, std::vector<c10::SymInt>& size, ::std::optional<c10::SymInt>& storage_offset, std::vector<c10::SymInt>& stride)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (as_strided_backward(grad, self_geometry, size, stride, storage_offset)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list AsStridedBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_geometry = packed_args.unpack<at::TensorGeometry>();
  auto size = packed_args.unpack<std::vector<c10::SymInt>>();
  auto storage_offset = packed_args.unpack<::std::optional<c10::SymInt>>();
  auto stride = packed_args.unpack<std::vector<c10::SymInt>>();
  return AsStridedBackward0_apply_functional(variable_list(grads), needs_input_grad, self_geometry, size, storage_offset, stride);
#endif
}

variable_list AsStridedBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return AsStridedBackward0_apply_functional(std::move(grads), needs_input_grad, self_geometry, size, storage_offset, stride);
}

void AsStridedBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_geometry);
    args.collect(size);
    args.collect(storage_offset);
    args.collect(stride);
}
variable_list AsStridedBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_geometry);
  saved.before(size);
  saved.before(storage_offset);
  saved.before(stride);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::TensorGeometry>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), AsStridedBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_geometry);
  packed_args.pack(size);
  packed_args.pack(storage_offset);
  packed_args.pack(stride);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_geometry);
  saved.after(size);
  saved.after(storage_offset);
  saved.after(stride);
  return output_result;
#endif
}

static variable_list AsStridedBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, at::TensorGeometry& self_geometry, std::vector<c10::SymInt>& size, ::std::optional<c10::SymInt>& storage_offset, std::vector<c10::SymInt>& stride)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (as_strided_backward(grad, self_geometry, size, stride, storage_offset)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list AsStridedBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_geometry = packed_args.unpack<at::TensorGeometry>();
  auto size = packed_args.unpack<std::vector<c10::SymInt>>();
  auto storage_offset = packed_args.unpack<::std::optional<c10::SymInt>>();
  auto stride = packed_args.unpack<std::vector<c10::SymInt>>();
  return AsStridedBackward1_apply_functional(variable_list(grads), needs_input_grad, self_geometry, size, storage_offset, stride);
#endif
}

variable_list AsStridedBackward1::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return AsStridedBackward1_apply_functional(std::move(grads), needs_input_grad, self_geometry, size, storage_offset, stride);
}

void AsStridedBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_geometry);
    args.collect(size);
    args.collect(storage_offset);
    args.collect(stride);
}
variable_list AsStridedBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_geometry);
  saved.before(size);
  saved.before(storage_offset);
  saved.before(stride);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::TensorGeometry>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), AsStridedBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_geometry);
  packed_args.pack(size);
  packed_args.pack(storage_offset);
  packed_args.pack(stride);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_geometry);
  saved.after(size);
  saved.after(storage_offset);
  saved.after(stride);
  return output_result;
#endif
}

static variable_list AsinBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad * (-self * self + 1).rsqrt().conj()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list AsinBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  return AsinBackward0_apply_functional(variable_list(grads), needs_input_grad, self);
#endif
}

variable_list AsinBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return AsinBackward0_apply_functional(std::move(grads), needs_input_grad, self);
}

void AsinBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list AsinBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), AsinBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list AtanBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad / (self * self + 1).conj()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list AtanBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  return AtanBackward0_apply_functional(variable_list(grads), needs_input_grad, self);
#endif
}

variable_list AtanBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return AtanBackward0_apply_functional(std::move(grads), needs_input_grad, self);
}

void AtanBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list AtanBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), AtanBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list Atan2Backward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& other, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1]) {
      auto grad_input_mask = std::array<bool, 2>{
        needs_input_grad[0],
        needs_input_grad[1],
      };
    auto grad_result = atan2_backward(grad, self, other, grad_input_mask);
      if (needs_input_grad[/*self*/0]) {
        copy_range(grad_inputs, self_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*other*/1]) {
        copy_range(grad_inputs, other_ix, std::get<1>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list Atan2Backward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto other = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<Tensor>();
  return Atan2Backward0_apply_functional(variable_list(grads), needs_input_grad, other, self);
#endif
}

variable_list Atan2Backward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto other = other_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  return Atan2Backward0_apply_functional(std::move(grads), needs_input_grad, other, self);
}

void Atan2Backward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(other_, false);
    args.collect(self_, false);
}
variable_list Atan2Backward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(other_);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), Atan2Backward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto other = other_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(other);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(other_);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list BaddbmmBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, at::Scalar& alpha, Tensor& batch1, Tensor& batch2, at::Scalar& beta)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto batch1_ix = gen.range(1);
  auto batch2_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*batch1*/1]) {
    auto grad_result = any_grad_defined ? (maybe_multiply(grad.bmm(batch2.transpose(1, 2).conj()), alpha.conj())) : Tensor();
    copy_range(grad_inputs, batch1_ix, grad_result);
  }
  if (needs_input_grad[/*batch2*/2]) {
    auto grad_result = any_grad_defined ? (maybe_multiply(batch1.transpose(1, 2).conj().bmm(grad), alpha.conj())) : Tensor();
    copy_range(grad_inputs, batch2_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (maybe_multiply(grad, beta.conj())) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list BaddbmmBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto alpha = packed_args.unpack<at::Scalar>();
  auto batch1 = packed_args.unpack<Tensor>();
  auto batch2 = packed_args.unpack<Tensor>();
  auto beta = packed_args.unpack<at::Scalar>();
  return BaddbmmBackward0_apply_functional(variable_list(grads), needs_input_grad, alpha, batch1, batch2, beta);
#endif
}

variable_list BaddbmmBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto batch1 = batch1_.unpack();
  auto batch2 = batch2_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto batch1_ix = gen.range(1);
  auto batch2_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ batch1_ix }),
    task_should_compute_output({ batch2_ix }),
  };
  return BaddbmmBackward0_apply_functional(std::move(grads), needs_input_grad, alpha, batch1, batch2, beta);
}

void BaddbmmBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(alpha);
    args.collect(batch1_, false);
    args.collect(batch2_, false);
    args.collect(beta);
}
variable_list BaddbmmBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(alpha);
  saved.before(batch1_);
  saved.before(batch2_);
  saved.before(beta);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), BaddbmmBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto batch1 = batch1_.unpack();
  auto batch2 = batch2_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto batch1_ix = gen.range(1);
  auto batch2_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ batch1_ix }),
    task_should_compute_output({ batch2_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(alpha);
  packed_args.pack(batch1);
  packed_args.pack(batch2);
  packed_args.pack(beta);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(alpha);
  saved.after(batch1_);
  saved.after(batch2_);
  saved.after(beta);
  return output_result;
#endif
}

static variable_list BernoulliBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (zeros_like(grad)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list BernoulliBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return BernoulliBackward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list BernoulliBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return BernoulliBackward0_apply_functional(std::move(grads), needs_input_grad);
}

void BernoulliBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list BernoulliBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), BernoulliBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list BernoulliBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, torch::autograd::generated::TypeAndSize& p_info)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto p_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*p*/1]) {
    auto grad_result = any_grad_defined ? (p_info.zeros()) : Tensor();
    copy_range(grad_inputs, p_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (zeros_like(grad)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list BernoulliBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto p_info = packed_args.unpack<torch::autograd::generated::TypeAndSize>();
  return BernoulliBackward1_apply_functional(variable_list(grads), needs_input_grad, p_info);
#endif
}

variable_list BernoulliBackward1::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto p_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ p_ix }),
  };
  return BernoulliBackward1_apply_functional(std::move(grads), needs_input_grad, p_info);
}

void BernoulliBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(p_info);
}
variable_list BernoulliBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(p_info);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::autograd::generated::TypeAndSize>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), BernoulliBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto p_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ p_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(p_info);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(p_info);
  return output_result;
#endif
}

static variable_list BernoulliBackward2_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (zeros_like(grad)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list BernoulliBackward2_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return BernoulliBackward2_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list BernoulliBackward2::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return BernoulliBackward2_apply_functional(std::move(grads), needs_input_grad);
}

void BernoulliBackward2::compiled_args(CompiledNodeArgs& args) const {

}
variable_list BernoulliBackward2::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), BernoulliBackward2_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list BmmBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& mat2, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto mat2_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*mat2*/1]) {
    auto grad_result = any_grad_defined ? (self.transpose(1, 2).conj().bmm(grad)) : Tensor();
    copy_range(grad_inputs, mat2_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.bmm(mat2.transpose(1, 2).conj())) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list BmmBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto mat2 = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<Tensor>();
  return BmmBackward0_apply_functional(variable_list(grads), needs_input_grad, mat2, self);
#endif
}

variable_list BmmBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto mat2 = mat2_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto mat2_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ mat2_ix }),
  };
  return BmmBackward0_apply_functional(std::move(grads), needs_input_grad, mat2, self);
}

void BmmBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(mat2_, false);
    args.collect(self_, false);
}
variable_list BmmBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(mat2_);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), BmmBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto mat2 = mat2_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto mat2_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ mat2_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(mat2);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(mat2_);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list MatmulBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& other, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1]) {
      auto grad_input_mask = std::array<bool, 2>{
        needs_input_grad[0],
        needs_input_grad[1],
      };
    auto grad_result = matmul_backward(grad, self, other, grad_input_mask);
      if (needs_input_grad[/*self*/0]) {
        copy_range(grad_inputs, self_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*other*/1]) {
        copy_range(grad_inputs, other_ix, std::get<1>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list MatmulBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto other = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<Tensor>();
  return MatmulBackward0_apply_functional(variable_list(grads), needs_input_grad, other, self);
#endif
}

variable_list MatmulBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto other = other_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  return MatmulBackward0_apply_functional(std::move(grads), needs_input_grad, other, self);
}

void MatmulBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(other_, false);
    args.collect(self_, false);
}
variable_list MatmulBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(other_);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MatmulBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto other = other_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(other);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(other_);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list CatBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t tensors_size_, int64_t& dim, ::std::vector<at::ScalarType>& tensors_args_scalartypes, ::std::vector<::std::vector<c10::SymInt>>& tensors_args_sizes_symint)
{
  IndexRangeGenerator gen;
  auto tensors_ix = gen.range(tensors_size_);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[/*tensors*/0]) {
    auto grad_result = cat_tensors_backward(grad, tensors_args_sizes_symint, tensors_args_scalartypes, dim);
    copy_range(grad_inputs, tensors_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list CatBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto tensors_size_ = packed_args.unpack<size_t>();
  auto dim = packed_args.unpack<int64_t>();
  auto tensors_args_scalartypes = packed_args.unpack<::std::vector<at::ScalarType>>();
  auto tensors_args_sizes_symint = packed_args.unpack<::std::vector<::std::vector<c10::SymInt>>>();
  return CatBackward0_apply_functional(variable_list(grads), needs_input_grad, tensors_size_, dim, tensors_args_scalartypes, tensors_args_sizes_symint);
#endif
}

variable_list CatBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto tensors_ix = gen.range(tensors_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ tensors_ix }),
  };
  return CatBackward0_apply_functional(std::move(grads), needs_input_grad, tensors_size_, dim, tensors_args_scalartypes, tensors_args_sizes_symint);
}

void CatBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(tensors_args_scalartypes);
    args.collect(tensors_args_sizes_symint);
}
variable_list CatBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(tensors_args_scalartypes);
  saved.before(tensors_args_sizes_symint);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::vector<at::ScalarType>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::vector<::std::vector<c10::SymInt>>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), CatBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto tensors_ix = gen.range(tensors_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ tensors_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(tensors_size_);
  packed_args.pack(dim);
  packed_args.pack(tensors_args_scalartypes);
  packed_args.pack(tensors_args_sizes_symint);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(tensors_args_scalartypes);
  saved.after(tensors_args_sizes_symint);
  return output_result;
#endif
}

static variable_list CauchyBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (zeros_like(grad)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list CauchyBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return CauchyBackward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list CauchyBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return CauchyBackward0_apply_functional(std::move(grads), needs_input_grad);
}

void CauchyBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list CauchyBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), CauchyBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list CeilBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (zeros_like(grad)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list CeilBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return CeilBackward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list CeilBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return CeilBackward0_apply_functional(std::move(grads), needs_input_grad);
}

void CeilBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list CeilBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), CeilBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list CholeskyBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, bool& upper, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (cholesky_backward(grad, upper, result)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list CholeskyBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto upper = packed_args.unpack<bool>();
  auto result = packed_args.unpack<Tensor>();
  return CholeskyBackward0_apply_functional(variable_list(grads), needs_input_grad, upper, result);
#endif
}

variable_list CholeskyBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return CholeskyBackward0_apply_functional(std::move(grads), needs_input_grad, upper, result);
}

void CholeskyBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(upper);
    args.collect(result_, true);
}
variable_list CholeskyBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(upper);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), CholeskyBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(upper);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(upper);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list ChunkBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = not_implemented("chunk");
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ChunkBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return ChunkBackward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list ChunkBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ChunkBackward0_apply_functional(std::move(grads), needs_input_grad);
}

void ChunkBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list ChunkBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ChunkBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list ChunkBackwardAutogradNestedTensor0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& chunks, int64_t& dim, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (chunk_backward_nested(grads, self, chunks, dim)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ChunkBackwardAutogradNestedTensor0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto chunks = packed_args.unpack<int64_t>();
  auto dim = packed_args.unpack<int64_t>();
  auto self = packed_args.unpack<Tensor>();
  return ChunkBackwardAutogradNestedTensor0_apply_functional(variable_list(grads), needs_input_grad, chunks, dim, self);
#endif
}

variable_list ChunkBackwardAutogradNestedTensor0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ChunkBackwardAutogradNestedTensor0_apply_functional(std::move(grads), needs_input_grad, chunks, dim, self);
}

void ChunkBackwardAutogradNestedTensor0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(chunks);
    args.collect(dim);
    args.collect(self_, false);
}
variable_list ChunkBackwardAutogradNestedTensor0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(chunks);
  saved.before(dim);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ChunkBackwardAutogradNestedTensor0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(chunks);
  packed_args.pack(dim);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(chunks);
  saved.after(dim);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list LinalgCholeskyExBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, bool& upper, Tensor& L)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (cholesky_backward(grad, upper, L)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list LinalgCholeskyExBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto upper = packed_args.unpack<bool>();
  auto L = packed_args.unpack<Tensor>();
  return LinalgCholeskyExBackward0_apply_functional(variable_list(grads), needs_input_grad, upper, L);
#endif
}

variable_list LinalgCholeskyExBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto L = L_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return LinalgCholeskyExBackward0_apply_functional(std::move(grads), needs_input_grad, upper, L);
}

void LinalgCholeskyExBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(upper);
    args.collect(L_, true);
}
variable_list LinalgCholeskyExBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(upper);
  saved.before(L_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), LinalgCholeskyExBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto L = L_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(upper);
  packed_args.pack(L);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(upper);
  saved.after(L_);
  return output_result;
#endif
}

static variable_list CholeskySolveBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& input2, Tensor& self, bool& upper, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto input2_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1]) {
      auto grad_input_mask = std::array<bool, 2>{
        needs_input_grad[0],
        needs_input_grad[1],
      };
    auto grad_result = cholesky_solve_backward(grad, self, input2, result, upper, grad_input_mask);
      if (needs_input_grad[/*self*/0]) {
        copy_range(grad_inputs, self_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*input2*/1]) {
        copy_range(grad_inputs, input2_ix, std::get<1>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list CholeskySolveBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto input2 = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<Tensor>();
  auto upper = packed_args.unpack<bool>();
  auto result = packed_args.unpack<Tensor>();
  return CholeskySolveBackward0_apply_functional(variable_list(grads), needs_input_grad, input2, self, upper, result);
#endif
}

variable_list CholeskySolveBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto input2 = input2_.unpack();
  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto input2_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ input2_ix }),
  };
  return CholeskySolveBackward0_apply_functional(std::move(grads), needs_input_grad, input2, self, upper, result);
}

void CholeskySolveBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(input2_, false);
    args.collect(self_, false);
    args.collect(upper);
    args.collect(result_, true);
}
variable_list CholeskySolveBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(input2_);
  saved.before(self_);
  saved.before(upper);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), CholeskySolveBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto input2 = input2_.unpack();
  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto input2_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ input2_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(input2);
  packed_args.pack(self);
  packed_args.pack(upper);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(input2_);
  saved.after(self_);
  saved.after(upper);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list CholeskyInverseBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self, bool& upper, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (cholesky_inverse_backward(grad, self, upper, result)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list CholeskyInverseBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  auto upper = packed_args.unpack<bool>();
  auto result = packed_args.unpack<Tensor>();
  return CholeskyInverseBackward0_apply_functional(variable_list(grads), needs_input_grad, self, upper, result);
#endif
}

variable_list CholeskyInverseBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return CholeskyInverseBackward0_apply_functional(std::move(grads), needs_input_grad, self, upper, result);
}

void CholeskyInverseBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
    args.collect(upper);
    args.collect(result_, true);
}
variable_list CholeskyInverseBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);
  saved.before(upper);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), CholeskyInverseBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);
  packed_args.pack(upper);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  saved.after(upper);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list ClampBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, Tensor& max, Tensor& min, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto min_ix = gen.range(1);
  auto max_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[1] || needs_input_grad[2]) {
      auto grad_input_mask = std::array<bool, 2>{
        needs_input_grad[1],
        needs_input_grad[2],
      };
    auto grad_result = clamp_backward_min_max(grad, self, min, max, grad_input_mask);
      if (needs_input_grad[/*min*/1]) {
        copy_range(grad_inputs, min_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*max*/2]) {
        copy_range(grad_inputs, max_ix, std::get<1>(grad_result));
      }
  }
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (clamp_backward(grad, self, min, max)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ClampBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto max = packed_args.unpack<Tensor>();
  auto min = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<Tensor>();
  return ClampBackward0_apply_functional(variable_list(grads), needs_input_grad, max, min, self);
#endif
}

variable_list ClampBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto max = max_.unpack();
  auto min = min_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto min_ix = gen.range(1);
  auto max_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ min_ix }),
    task_should_compute_output({ max_ix }),
  };
  return ClampBackward0_apply_functional(std::move(grads), needs_input_grad, max, min, self);
}

void ClampBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(max_, false);
    args.collect(min_, false);
    args.collect(self_, false);
}
variable_list ClampBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(max_);
  saved.before(min_);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ClampBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto max = max_.unpack();
  auto min = min_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto min_ix = gen.range(1);
  auto max_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ min_ix }),
    task_should_compute_output({ max_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(max);
  packed_args.pack(min);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(max_);
  saved.after(min_);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list ClampBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, ::std::optional<at::Scalar>& max, ::std::optional<at::Scalar>& min, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (clamp_backward(grad, self, min, max)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ClampBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto max = packed_args.unpack<::std::optional<at::Scalar>>();
  auto min = packed_args.unpack<::std::optional<at::Scalar>>();
  auto self = packed_args.unpack<Tensor>();
  return ClampBackward1_apply_functional(variable_list(grads), needs_input_grad, max, min, self);
#endif
}

variable_list ClampBackward1::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ClampBackward1_apply_functional(std::move(grads), needs_input_grad, max, min, self);
}

void ClampBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(max);
    args.collect(min);
    args.collect(self_, false);
}
variable_list ClampBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(max);
  saved.before(min);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<at::Scalar>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<at::Scalar>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ClampBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(max);
  packed_args.pack(min);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(max);
  saved.after(min);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list ClampMinBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, at::Scalar& min, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (where(self >= min, grad, at::scalar_tensor(0., grad.options()))) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ClampMinBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto min = packed_args.unpack<at::Scalar>();
  auto self = packed_args.unpack<Tensor>();
  return ClampMinBackward0_apply_functional(variable_list(grads), needs_input_grad, min, self);
#endif
}

variable_list ClampMinBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ClampMinBackward0_apply_functional(std::move(grads), needs_input_grad, min, self);
}

void ClampMinBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(min);
    args.collect(self_, false);
}
variable_list ClampMinBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(min);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ClampMinBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(min);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(min);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list ClampMinBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& min, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto min_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*min*/1]) {
    auto grad_result = any_grad_defined ? (where(self < min, grad, at::scalar_tensor(0., grad.options()))) : Tensor();
    copy_range(grad_inputs, min_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (where(self >= min, grad, at::scalar_tensor(0., grad.options()))) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ClampMinBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto min = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<Tensor>();
  return ClampMinBackward1_apply_functional(variable_list(grads), needs_input_grad, min, self);
#endif
}

variable_list ClampMinBackward1::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto min = min_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto min_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ min_ix }),
  };
  return ClampMinBackward1_apply_functional(std::move(grads), needs_input_grad, min, self);
}

void ClampMinBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(min_, false);
    args.collect(self_, false);
}
variable_list ClampMinBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(min_);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ClampMinBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto min = min_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto min_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ min_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(min);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(min_);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list ClampMaxBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, at::Scalar& max, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (where(self <= max, grad, at::scalar_tensor(0., grad.options()))) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ClampMaxBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto max = packed_args.unpack<at::Scalar>();
  auto self = packed_args.unpack<Tensor>();
  return ClampMaxBackward0_apply_functional(variable_list(grads), needs_input_grad, max, self);
#endif
}

variable_list ClampMaxBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ClampMaxBackward0_apply_functional(std::move(grads), needs_input_grad, max, self);
}

void ClampMaxBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(max);
    args.collect(self_, false);
}
variable_list ClampMaxBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(max);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ClampMaxBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(max);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(max);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list ClampMaxBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& max, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto max_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*max*/1]) {
    auto grad_result = any_grad_defined ? (where(self > max, grad, at::scalar_tensor(0., grad.options()))) : Tensor();
    copy_range(grad_inputs, max_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (where(self <= max, grad, at::scalar_tensor(0., grad.options()))) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ClampMaxBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto max = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<Tensor>();
  return ClampMaxBackward1_apply_functional(variable_list(grads), needs_input_grad, max, self);
#endif
}

variable_list ClampMaxBackward1::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto max = max_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto max_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ max_ix }),
  };
  return ClampMaxBackward1_apply_functional(std::move(grads), needs_input_grad, max, self);
}

void ClampMaxBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(max_, false);
    args.collect(self_, false);
}
variable_list ClampMaxBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(max_);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ClampMaxBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto max = max_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto max_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ max_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(max);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(max_);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list CloneBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list CloneBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return CloneBackward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list CloneBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return CloneBackward0_apply_functional(std::move(grads), needs_input_grad);
}

void CloneBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list CloneBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), CloneBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list LazyCloneBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list LazyCloneBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return LazyCloneBackward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list LazyCloneBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return LazyCloneBackward0_apply_functional(std::move(grads), needs_input_grad);
}

void LazyCloneBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list LazyCloneBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), LazyCloneBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list ToCopyBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, at::TensorOptions& self_options)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (_to_copy_backward(grad, self_options)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ToCopyBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_options = packed_args.unpack<at::TensorOptions>();
  return ToCopyBackward0_apply_functional(variable_list(grads), needs_input_grad, self_options);
#endif
}

variable_list ToCopyBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ToCopyBackward0_apply_functional(std::move(grads), needs_input_grad, self_options);
}

void ToCopyBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_options);
}
variable_list ToCopyBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_options);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::TensorOptions>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ToCopyBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_options);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_options);
  return output_result;
#endif
}

static variable_list CoalesceBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list CoalesceBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return CoalesceBackward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list CoalesceBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return CoalesceBackward0_apply_functional(std::move(grads), needs_input_grad);
}

void CoalesceBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list CoalesceBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), CoalesceBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list ComplexBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& imag, Tensor& real)
{
  IndexRangeGenerator gen;
  auto real_ix = gen.range(1);
  auto imag_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*imag*/1]) {
    auto grad_result = any_grad_defined ? (at::imag(grad)) : Tensor();
    copy_range(grad_inputs, imag_ix, grad_result);
  }
  if (needs_input_grad[/*real*/0]) {
    auto grad_result = any_grad_defined ? (at::real(grad)) : Tensor();
    copy_range(grad_inputs, real_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ComplexBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto imag = packed_args.unpack<Tensor>();
  auto real = packed_args.unpack<Tensor>();
  return ComplexBackward0_apply_functional(variable_list(grads), needs_input_grad, imag, real);
#endif
}

variable_list ComplexBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto imag = imag_.unpack();
  auto real = real_.unpack();
  IndexRangeGenerator gen;
  auto real_ix = gen.range(1);
  auto imag_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ real_ix }),
    task_should_compute_output({ imag_ix }),
  };
  return ComplexBackward0_apply_functional(std::move(grads), needs_input_grad, imag, real);
}

void ComplexBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(imag_, false);
    args.collect(real_, false);
}
variable_list ComplexBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(imag_);
  saved.before(real_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ComplexBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto imag = imag_.unpack();
  auto real = real_.unpack();
  IndexRangeGenerator gen;
  auto real_ix = gen.range(1);
  auto imag_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ real_ix }),
    task_should_compute_output({ imag_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(imag);
  packed_args.pack(real);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(imag_);
  saved.after(real_);
  return output_result;
#endif
}

static variable_list PolarBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& result)
{
  IndexRangeGenerator gen;
  auto abs_ix = gen.range(1);
  auto angle_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1]) {
  
    auto grad_result = polar_backward(grad, result);
      if (needs_input_grad[/*abs*/0]) {
        copy_range(grad_inputs, abs_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*angle*/1]) {
        copy_range(grad_inputs, angle_ix, std::get<1>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list PolarBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto result = packed_args.unpack<Tensor>();
  return PolarBackward0_apply_functional(variable_list(grads), needs_input_grad, result);
#endif
}

variable_list PolarBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto abs_ix = gen.range(1);
  auto angle_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ abs_ix }),
    task_should_compute_output({ angle_ix }),
  };
  return PolarBackward0_apply_functional(std::move(grads), needs_input_grad, result);
}

void PolarBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(result_, true);
}
variable_list PolarBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), PolarBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto abs_ix = gen.range(1);
  auto angle_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ abs_ix }),
    task_should_compute_output({ angle_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(result_);
  return output_result;
#endif
}

static variable_list ConjBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.conj()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ConjBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return ConjBackward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list ConjBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ConjBackward0_apply_functional(std::move(grads), needs_input_grad);
}

void ConjBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list ConjBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ConjBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list NegViewBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.neg()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list NegViewBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return NegViewBackward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list NegViewBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return NegViewBackward0_apply_functional(std::move(grads), needs_input_grad);
}

void NegViewBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list NegViewBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), NegViewBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list ConjPhysicalBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.conj_physical()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ConjPhysicalBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return ConjPhysicalBackward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list ConjPhysicalBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ConjPhysicalBackward0_apply_functional(std::move(grads), needs_input_grad);
}

void ConjPhysicalBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list ConjPhysicalBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ConjPhysicalBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list ConjPhysicalBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.conj_physical()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ConjPhysicalBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return ConjPhysicalBackward1_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list ConjPhysicalBackward1::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ConjPhysicalBackward1_apply_functional(std::move(grads), needs_input_grad);
}

void ConjPhysicalBackward1::compiled_args(CompiledNodeArgs& args) const {

}
variable_list ConjPhysicalBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ConjPhysicalBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list CopysignBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, torch::autograd::generated::TypeAndSize& other_info, Tensor& self, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*other*/1]) {
    auto grad_result = any_grad_defined ? (other_info.zeros()) : Tensor();
    copy_range(grad_inputs, other_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (copysign_tensor_self_backward(grad, self, result)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list CopysignBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto other_info = packed_args.unpack<torch::autograd::generated::TypeAndSize>();
  auto self = packed_args.unpack<Tensor>();
  auto result = packed_args.unpack<Tensor>();
  return CopysignBackward0_apply_functional(variable_list(grads), needs_input_grad, other_info, self, result);
#endif
}

variable_list CopysignBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  return CopysignBackward0_apply_functional(std::move(grads), needs_input_grad, other_info, self, result);
}

void CopysignBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(other_info);
    args.collect(self_, false);
    args.collect(result_, true);
}
variable_list CopysignBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(other_info);
  saved.before(self_);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::autograd::generated::TypeAndSize>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), CopysignBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(other_info);
  packed_args.pack(self);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(other_info);
  saved.after(self_);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list CopysignBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (copysign_tensor_self_backward(grad, self, result)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list CopysignBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  auto result = packed_args.unpack<Tensor>();
  return CopysignBackward1_apply_functional(variable_list(grads), needs_input_grad, self, result);
#endif
}

variable_list CopysignBackward1::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return CopysignBackward1_apply_functional(std::move(grads), needs_input_grad, self, result);
}

void CopysignBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
    args.collect(result_, true);
}
variable_list CopysignBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), CopysignBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list CosBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad * -self.sin().conj()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list CosBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  return CosBackward0_apply_functional(variable_list(grads), needs_input_grad, self);
#endif
}

variable_list CosBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return CosBackward0_apply_functional(std::move(grads), needs_input_grad, self);
}

void CosBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list CosBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), CosBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list CoshBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad * self.sinh().conj()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list CoshBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  return CoshBackward0_apply_functional(variable_list(grads), needs_input_grad, self);
#endif
}

variable_list CoshBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return CoshBackward0_apply_functional(std::move(grads), needs_input_grad, self);
}

void CoshBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list CoshBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), CoshBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list LinalgCrossBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, int64_t& dim, Tensor& other, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*other*/1]) {
    auto grad_result = any_grad_defined ? (at::linalg_cross(grad, self.conj(), dim)) : Tensor();
    copy_range(grad_inputs, other_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (at::linalg_cross(other.conj(), grad, dim)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list LinalgCrossBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto dim = packed_args.unpack<int64_t>();
  auto other = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<Tensor>();
  return LinalgCrossBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, other, self);
#endif
}

variable_list LinalgCrossBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto other = other_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  return LinalgCrossBackward0_apply_functional(std::move(grads), needs_input_grad, dim, other, self);
}

void LinalgCrossBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(other_, false);
    args.collect(self_, false);
}
variable_list LinalgCrossBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(other_);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), LinalgCrossBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto other = other_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(other);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(other_);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list LogcumsumexpBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim, Tensor& self, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (logcumsumexp_backward(grad, self, result, dim)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list LogcumsumexpBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  auto self = packed_args.unpack<Tensor>();
  auto result = packed_args.unpack<Tensor>();
  return LogcumsumexpBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, self, result);
#endif
}

variable_list LogcumsumexpBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return LogcumsumexpBackward0_apply_functional(std::move(grads), needs_input_grad, dim, self, result);
}

void LogcumsumexpBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(self_, false);
    args.collect(result_, true);
}
variable_list LogcumsumexpBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(self_);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), LogcumsumexpBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(self);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(self_);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list CumprodBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim, Tensor& self, at::ScalarType& self_scalar_type, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (cumprod_backward(grad.to(self_scalar_type), self, dim, result)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list CumprodBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  auto self = packed_args.unpack<Tensor>();
  auto self_scalar_type = packed_args.unpack<at::ScalarType>();
  auto result = packed_args.unpack<Tensor>();
  return CumprodBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, self, self_scalar_type, result);
#endif
}

variable_list CumprodBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return CumprodBackward0_apply_functional(std::move(grads), needs_input_grad, dim, self, self_scalar_type, result);
}

void CumprodBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(self_, false);
    args.collect(self_scalar_type);
    args.collect(result_, true);
}
variable_list CumprodBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(self_);
  saved.before(self_scalar_type);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::ScalarType>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), CumprodBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(self);
  packed_args.pack(self_scalar_type);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(self_);
  saved.after(self_scalar_type);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list CumsumBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim, at::ScalarType& self_scalar_type)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (cumsum_backward(grad.to(self_scalar_type), dim)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list CumsumBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  auto self_scalar_type = packed_args.unpack<at::ScalarType>();
  return CumsumBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, self_scalar_type);
#endif
}

variable_list CumsumBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return CumsumBackward0_apply_functional(std::move(grads), needs_input_grad, dim, self_scalar_type);
}

void CumsumBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(self_scalar_type);
}
variable_list CumsumBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(self_scalar_type);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::ScalarType>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), CumsumBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(self_scalar_type);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(self_scalar_type);
  return output_result;
#endif
}

static variable_list CummaxBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim, Tensor& self, Tensor& indices)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (cummaxmin_backward(grad, self, indices, dim)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list CummaxBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  auto self = packed_args.unpack<Tensor>();
  auto indices = packed_args.unpack<Tensor>();
  return CummaxBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, self, indices);
#endif
}

variable_list CummaxBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto indices = indices_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return CummaxBackward0_apply_functional(std::move(grads), needs_input_grad, dim, self, indices);
}

void CummaxBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(self_, false);
    args.collect(indices_, true);
}
variable_list CummaxBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(self_);
  saved.before(indices_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), CummaxBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto indices = indices_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(self);
  packed_args.pack(indices);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(self_);
  saved.after(indices_);
  return output_result;
#endif
}

static variable_list CumminBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim, Tensor& self, Tensor& indices)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (cummaxmin_backward(grad, self, indices, dim)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list CumminBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  auto self = packed_args.unpack<Tensor>();
  auto indices = packed_args.unpack<Tensor>();
  return CumminBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, self, indices);
#endif
}

variable_list CumminBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto indices = indices_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return CumminBackward0_apply_functional(std::move(grads), needs_input_grad, dim, self, indices);
}

void CumminBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(self_, false);
    args.collect(indices_, true);
}
variable_list CumminBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(self_);
  saved.before(indices_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), CumminBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto indices = indices_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(self);
  packed_args.pack(indices);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(self_);
  saved.after(indices_);
  return output_result;
#endif
}

static variable_list ConvTbcBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, Tensor& bias, int64_t& pad, Tensor& self, Tensor& weight)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1] || needs_input_grad[2]) {
  
    auto grad_result = grad.defined() ? conv_tbc_backward(grad, self, weight, bias, pad) : std::tuple<Tensor, Tensor, Tensor>();
      if (needs_input_grad[/*self*/0]) {
        copy_range(grad_inputs, self_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*weight*/1]) {
        copy_range(grad_inputs, weight_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*bias*/2]) {
        copy_range(grad_inputs, bias_ix, std::get<2>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list ConvTbcBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto bias = packed_args.unpack<Tensor>();
  auto pad = packed_args.unpack<int64_t>();
  auto self = packed_args.unpack<Tensor>();
  auto weight = packed_args.unpack<Tensor>();
  return ConvTbcBackward0_apply_functional(variable_list(grads), needs_input_grad, bias, pad, self, weight);
#endif
}

variable_list ConvTbcBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto bias = bias_.unpack();
  auto self = self_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  return ConvTbcBackward0_apply_functional(std::move(grads), needs_input_grad, bias, pad, self, weight);
}

void ConvTbcBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(bias_, false);
    args.collect(pad);
    args.collect(self_, false);
    args.collect(weight_, false);
}
variable_list ConvTbcBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(bias_);
  saved.before(pad);
  saved.before(self_);
  saved.before(weight_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ConvTbcBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto bias = bias_.unpack();
  auto self = self_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(bias);
  packed_args.pack(pad);
  packed_args.pack(self);
  packed_args.pack(weight);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(bias_);
  saved.after(pad);
  saved.after(self_);
  saved.after(weight_);
  return output_result;
#endif
}

static variable_list CtcLossBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& blank, std::vector<int64_t>& input_lengths, Tensor& log_probs, std::vector<int64_t>& target_lengths, Tensor& targets, bool& zero_infinity, Tensor& result0, Tensor& result1)
{
  IndexRangeGenerator gen;
  auto log_probs_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*log_probs*/0]) {
    auto grad_result = any_grad_defined ? (_ctc_loss_backward(grad, log_probs, targets, input_lengths, target_lengths, result0, result1, blank, zero_infinity)) : Tensor();
    copy_range(grad_inputs, log_probs_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list CtcLossBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto blank = packed_args.unpack<int64_t>();
  auto input_lengths = packed_args.unpack<std::vector<int64_t>>();
  auto log_probs = packed_args.unpack<Tensor>();
  auto target_lengths = packed_args.unpack<std::vector<int64_t>>();
  auto targets = packed_args.unpack<Tensor>();
  auto zero_infinity = packed_args.unpack<bool>();
  auto result0 = packed_args.unpack<Tensor>();
  auto result1 = packed_args.unpack<Tensor>();
  return CtcLossBackward0_apply_functional(variable_list(grads), needs_input_grad, blank, input_lengths, log_probs, target_lengths, targets, zero_infinity, result0, result1);
#endif
}

variable_list CtcLossBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto log_probs = log_probs_.unpack();
  auto targets = targets_.unpack();
  auto result0 = result0_.unpack(shared_from_this());
  auto result1 = result1_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto log_probs_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ log_probs_ix }),
  };
  return CtcLossBackward0_apply_functional(std::move(grads), needs_input_grad, blank, input_lengths, log_probs, target_lengths, targets, zero_infinity, result0, result1);
}

void CtcLossBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(blank);
    args.collect(input_lengths);
    args.collect(log_probs_, false);
    args.collect(target_lengths);
    args.collect(targets_, false);
    args.collect(zero_infinity);
    args.collect(result0_, true);
    args.collect(result1_, true);
}
variable_list CtcLossBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(blank);
  saved.before(input_lengths);
  saved.before(log_probs_);
  saved.before(target_lengths);
  saved.before(targets_);
  saved.before(zero_infinity);
  saved.before(result0_);
  saved.before(result1_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), CtcLossBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto log_probs = log_probs_.unpack();
  auto targets = targets_.unpack();
  auto result0 = result0_.unpack(shared_from_this());
  auto result1 = result1_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto log_probs_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ log_probs_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(blank);
  packed_args.pack(input_lengths);
  packed_args.pack(log_probs);
  packed_args.pack(target_lengths);
  packed_args.pack(targets);
  packed_args.pack(zero_infinity);
  packed_args.pack(result0);
  packed_args.pack(result1);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(blank);
  saved.after(input_lengths);
  saved.after(log_probs_);
  saved.after(target_lengths);
  saved.after(targets_);
  saved.after(zero_infinity);
  saved.after(result0_);
  saved.after(result1_);
  return output_result;
#endif
}

static variable_list CtcLossBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& blank, Tensor& input_lengths, Tensor& log_probs, Tensor& target_lengths, Tensor& targets, bool& zero_infinity, Tensor& result0, Tensor& result1)
{
  IndexRangeGenerator gen;
  auto log_probs_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*log_probs*/0]) {
    auto grad_result = any_grad_defined ? (_ctc_loss_backward(grad, log_probs, targets, input_lengths, target_lengths, result0, result1, blank, zero_infinity)) : Tensor();
    copy_range(grad_inputs, log_probs_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list CtcLossBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto blank = packed_args.unpack<int64_t>();
  auto input_lengths = packed_args.unpack<Tensor>();
  auto log_probs = packed_args.unpack<Tensor>();
  auto target_lengths = packed_args.unpack<Tensor>();
  auto targets = packed_args.unpack<Tensor>();
  auto zero_infinity = packed_args.unpack<bool>();
  auto result0 = packed_args.unpack<Tensor>();
  auto result1 = packed_args.unpack<Tensor>();
  return CtcLossBackward1_apply_functional(variable_list(grads), needs_input_grad, blank, input_lengths, log_probs, target_lengths, targets, zero_infinity, result0, result1);
#endif
}

variable_list CtcLossBackward1::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto input_lengths = input_lengths_.unpack();
  auto log_probs = log_probs_.unpack();
  auto target_lengths = target_lengths_.unpack();
  auto targets = targets_.unpack();
  auto result0 = result0_.unpack(shared_from_this());
  auto result1 = result1_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto log_probs_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ log_probs_ix }),
  };
  return CtcLossBackward1_apply_functional(std::move(grads), needs_input_grad, blank, input_lengths, log_probs, target_lengths, targets, zero_infinity, result0, result1);
}

void CtcLossBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(blank);
    args.collect(input_lengths_, false);
    args.collect(log_probs_, false);
    args.collect(target_lengths_, false);
    args.collect(targets_, false);
    args.collect(zero_infinity);
    args.collect(result0_, true);
    args.collect(result1_, true);
}
variable_list CtcLossBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(blank);
  saved.before(input_lengths_);
  saved.before(log_probs_);
  saved.before(target_lengths_);
  saved.before(targets_);
  saved.before(zero_infinity);
  saved.before(result0_);
  saved.before(result1_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), CtcLossBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto input_lengths = input_lengths_.unpack();
  auto log_probs = log_probs_.unpack();
  auto target_lengths = target_lengths_.unpack();
  auto targets = targets_.unpack();
  auto result0 = result0_.unpack(shared_from_this());
  auto result1 = result1_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto log_probs_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ log_probs_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(blank);
  packed_args.pack(input_lengths);
  packed_args.pack(log_probs);
  packed_args.pack(target_lengths);
  packed_args.pack(targets);
  packed_args.pack(zero_infinity);
  packed_args.pack(result0);
  packed_args.pack(result1);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(blank);
  saved.after(input_lengths_);
  saved.after(log_probs_);
  saved.after(target_lengths_);
  saved.after(targets_);
  saved.after(zero_infinity);
  saved.after(result0_);
  saved.after(result1_);
  return output_result;
#endif
}

static variable_list Deg2RadBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (deg2rad_backward(grad)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list Deg2RadBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return Deg2RadBackward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list Deg2RadBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return Deg2RadBackward0_apply_functional(std::move(grads), needs_input_grad);
}

void Deg2RadBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list Deg2RadBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), Deg2RadBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list LinalgDetBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& A, Tensor& LU, Tensor& pivots, Tensor& result)
{
  IndexRangeGenerator gen;
  auto A_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*A*/0]) {
    auto grad_result = any_grad_defined ? (linalg_det_backward(grad, result, A, LU, pivots)) : Tensor();
    copy_range(grad_inputs, A_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list LinalgDetBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto A = packed_args.unpack<Tensor>();
  auto LU = packed_args.unpack<Tensor>();
  auto pivots = packed_args.unpack<Tensor>();
  auto result = packed_args.unpack<Tensor>();
  return LinalgDetBackward0_apply_functional(variable_list(grads), needs_input_grad, A, LU, pivots, result);
#endif
}

variable_list LinalgDetBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto A = A_.unpack();
  auto LU = LU_.unpack(shared_from_this());
  auto pivots = pivots_.unpack(shared_from_this());
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto A_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ A_ix }),
  };
  return LinalgDetBackward0_apply_functional(std::move(grads), needs_input_grad, A, LU, pivots, result);
}

void LinalgDetBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(A_, false);
    args.collect(LU_, true);
    args.collect(pivots_, true);
    args.collect(result_, true);
}
variable_list LinalgDetBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(A_);
  saved.before(LU_);
  saved.before(pivots_);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), LinalgDetBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto A = A_.unpack();
  auto LU = LU_.unpack(shared_from_this());
  auto pivots = pivots_.unpack(shared_from_this());
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto A_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ A_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(A);
  packed_args.pack(LU);
  packed_args.pack(pivots);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(A_);
  saved.after(LU_);
  saved.after(pivots_);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list LinalgSlogdetBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& A, Tensor& LU, Tensor& pivots, Tensor& sign)
{
  IndexRangeGenerator gen;
  auto A_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad_logabsdet = grads[1];
  const auto& grad_sign = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*A*/0]) {
    auto grad_result = any_grad_defined ? (slogdet_backward(grad_sign, grad_logabsdet, A, sign, LU, pivots)) : Tensor();
    copy_range(grad_inputs, A_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list LinalgSlogdetBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto A = packed_args.unpack<Tensor>();
  auto LU = packed_args.unpack<Tensor>();
  auto pivots = packed_args.unpack<Tensor>();
  auto sign = packed_args.unpack<Tensor>();
  return LinalgSlogdetBackward0_apply_functional(variable_list(grads), needs_input_grad, A, LU, pivots, sign);
#endif
}

variable_list LinalgSlogdetBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto A = A_.unpack();
  auto LU = LU_.unpack(shared_from_this());
  auto pivots = pivots_.unpack(shared_from_this());
  auto sign = sign_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto A_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ A_ix }),
  };
  return LinalgSlogdetBackward0_apply_functional(std::move(grads), needs_input_grad, A, LU, pivots, sign);
}

void LinalgSlogdetBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(A_, false);
    args.collect(LU_, true);
    args.collect(pivots_, true);
    args.collect(sign_, true);
}
variable_list LinalgSlogdetBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(A_);
  saved.before(LU_);
  saved.before(pivots_);
  saved.before(sign_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), LinalgSlogdetBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto A = A_.unpack();
  auto LU = LU_.unpack(shared_from_this());
  auto pivots = pivots_.unpack(shared_from_this());
  auto sign = sign_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto A_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ A_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(A);
  packed_args.pack(LU);
  packed_args.pack(pivots);
  packed_args.pack(sign);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(A_);
  saved.after(LU_);
  saved.after(pivots_);
  saved.after(sign_);
  return output_result;
#endif
}

static variable_list BlockDiagBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t tensors_size_, ::std::vector<at::ScalarType>& tensors_args_scalartypes, ::std::vector<::std::vector<int64_t>>& tensors_args_sizes)
{
  IndexRangeGenerator gen;
  auto tensors_ix = gen.range(tensors_size_);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[/*tensors*/0]) {
    auto grad_result = block_diag_backward(grad, tensors_args_sizes, tensors_args_scalartypes);
    copy_range(grad_inputs, tensors_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list BlockDiagBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto tensors_size_ = packed_args.unpack<size_t>();
  auto tensors_args_scalartypes = packed_args.unpack<::std::vector<at::ScalarType>>();
  auto tensors_args_sizes = packed_args.unpack<::std::vector<::std::vector<int64_t>>>();
  return BlockDiagBackward0_apply_functional(variable_list(grads), needs_input_grad, tensors_size_, tensors_args_scalartypes, tensors_args_sizes);
#endif
}

variable_list BlockDiagBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto tensors_ix = gen.range(tensors_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ tensors_ix }),
  };
  return BlockDiagBackward0_apply_functional(std::move(grads), needs_input_grad, tensors_size_, tensors_args_scalartypes, tensors_args_sizes);
}

void BlockDiagBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(tensors_args_scalartypes);
    args.collect(tensors_args_sizes);
}
variable_list BlockDiagBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(tensors_args_scalartypes);
  saved.before(tensors_args_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::vector<at::ScalarType>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::vector<::std::vector<int64_t>>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), BlockDiagBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto tensors_ix = gen.range(tensors_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ tensors_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(tensors_size_);
  packed_args.pack(tensors_args_scalartypes);
  packed_args.pack(tensors_args_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(tensors_args_scalartypes);
  saved.after(tensors_args_sizes);
  return output_result;
#endif
}

static variable_list DiagEmbedBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim1, int64_t& dim2, int64_t& offset)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.diagonal(offset, dim1, dim2)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list DiagEmbedBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim1 = packed_args.unpack<int64_t>();
  auto dim2 = packed_args.unpack<int64_t>();
  auto offset = packed_args.unpack<int64_t>();
  return DiagEmbedBackward0_apply_functional(variable_list(grads), needs_input_grad, dim1, dim2, offset);
#endif
}

variable_list DiagEmbedBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return DiagEmbedBackward0_apply_functional(std::move(grads), needs_input_grad, dim1, dim2, offset);
}

void DiagEmbedBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim1);
    args.collect(dim2);
    args.collect(offset);
}
variable_list DiagEmbedBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim1);
  saved.before(dim2);
  saved.before(offset);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), DiagEmbedBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim1);
  packed_args.pack(dim2);
  packed_args.pack(offset);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim1);
  saved.after(dim2);
  saved.after(offset);
  return output_result;
#endif
}

static variable_list DiagonalBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim1, int64_t& dim2, int64_t& offset, std::vector<c10::SymInt>& self_sym_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (diagonal_backward_symint(grad, self_sym_sizes, offset, dim1, dim2)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list DiagonalBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim1 = packed_args.unpack<int64_t>();
  auto dim2 = packed_args.unpack<int64_t>();
  auto offset = packed_args.unpack<int64_t>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return DiagonalBackward0_apply_functional(variable_list(grads), needs_input_grad, dim1, dim2, offset, self_sym_sizes);
#endif
}

variable_list DiagonalBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return DiagonalBackward0_apply_functional(std::move(grads), needs_input_grad, dim1, dim2, offset, self_sym_sizes);
}

void DiagonalBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim1);
    args.collect(dim2);
    args.collect(offset);
    args.collect(self_sym_sizes);
}
variable_list DiagonalBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim1);
  saved.before(dim2);
  saved.before(offset);
  saved.before(self_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), DiagonalBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim1);
  packed_args.pack(dim2);
  packed_args.pack(offset);
  packed_args.pack(self_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim1);
  saved.after(dim2);
  saved.after(offset);
  saved.after(self_sym_sizes);
  return output_result;
#endif
}

static variable_list DiagonalBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim1, int64_t& dim2, int64_t& offset)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (grad.diagonal(offset, dim1, dim2)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list DiagonalBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim1 = packed_args.unpack<int64_t>();
  auto dim2 = packed_args.unpack<int64_t>();
  auto offset = packed_args.unpack<int64_t>();
  return DiagonalBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, dim1, dim2, offset);
#endif
}

variable_list DiagonalBackwardBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ grad_output_ix }),
  };
  return DiagonalBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, dim1, dim2, offset);
}

void DiagonalBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim1);
    args.collect(dim2);
    args.collect(offset);
}
variable_list DiagonalBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim1);
  saved.before(dim2);
  saved.before(offset);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), DiagonalBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ grad_output_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim1);
  packed_args.pack(dim2);
  packed_args.pack(offset);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim1);
  saved.after(dim2);
  saved.after(offset);
  return output_result;
#endif
}

static variable_list DistBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& other, at::Scalar& p, Tensor& self, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*other*/1]) {
    auto grad_result = any_grad_defined ? (-norm_backward(grad, self - other, p, result)) : Tensor();
    copy_range(grad_inputs, other_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (norm_backward(grad, self - other, p, result)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list DistBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto other = packed_args.unpack<Tensor>();
  auto p = packed_args.unpack<at::Scalar>();
  auto self = packed_args.unpack<Tensor>();
  auto result = packed_args.unpack<Tensor>();
  return DistBackward0_apply_functional(variable_list(grads), needs_input_grad, other, p, self, result);
#endif
}

variable_list DistBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto other = other_.unpack();
  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  return DistBackward0_apply_functional(std::move(grads), needs_input_grad, other, p, self, result);
}

void DistBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(other_, false);
    args.collect(p);
    args.collect(self_, false);
    args.collect(result_, true);
}
variable_list DistBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(other_);
  saved.before(p);
  saved.before(self_);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), DistBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto other = other_.unpack();
  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(other);
  packed_args.pack(p);
  packed_args.pack(self);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(other_);
  saved.after(p);
  saved.after(self_);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list DivBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& other, Tensor& self, at::ScalarType& self_scalar_type)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*other*/1]) {
    auto grad_result = any_grad_defined ? (div_tensor_other_backward(grad, self, other)) : Tensor();
    copy_range(grad_inputs, other_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (div_tensor_self_backward(grad, other, self_scalar_type)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list DivBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto other = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<Tensor>();
  auto self_scalar_type = packed_args.unpack<at::ScalarType>();
  return DivBackward0_apply_functional(variable_list(grads), needs_input_grad, other, self, self_scalar_type);
#endif
}

variable_list DivBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto other = other_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  return DivBackward0_apply_functional(std::move(grads), needs_input_grad, other, self, self_scalar_type);
}

void DivBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(other_, false);
    args.collect(self_, false);
    args.collect(self_scalar_type);
}
variable_list DivBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(other_);
  saved.before(self_);
  saved.before(self_scalar_type);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::ScalarType>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), DivBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto other = other_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(other);
  packed_args.pack(self);
  packed_args.pack(self_scalar_type);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(other_);
  saved.after(self_);
  saved.after(self_scalar_type);
  return output_result;
#endif
}

static variable_list DivBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, at::Scalar& other, at::ScalarType& self_scalar_type)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (div_tensor_self_backward(grad, other, self_scalar_type)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list DivBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto other = packed_args.unpack<at::Scalar>();
  auto self_scalar_type = packed_args.unpack<at::ScalarType>();
  return DivBackward1_apply_functional(variable_list(grads), needs_input_grad, other, self_scalar_type);
#endif
}

variable_list DivBackward1::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return DivBackward1_apply_functional(std::move(grads), needs_input_grad, other, self_scalar_type);
}

void DivBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(other);
    args.collect(self_scalar_type);
}
variable_list DivBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(other);
  saved.before(self_scalar_type);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::ScalarType>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), DivBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(other);
  packed_args.pack(self_scalar_type);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(other);
  saved.after(self_scalar_type);
  return output_result;
#endif
}

static variable_list DivBackward2_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& other, std::optional<std::string>& rounding_mode, Tensor& self, at::ScalarType& self_scalar_type)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*other*/1]) {
    auto grad_result = any_grad_defined ? (div_tensor_other_backward(grad, self, other, rounding_mode.has_value() ? std::optional<std::string_view>(rounding_mode.value()) : std::nullopt)) : Tensor();
    copy_range(grad_inputs, other_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (div_tensor_self_backward(grad, other, self_scalar_type, rounding_mode.has_value() ? std::optional<std::string_view>(rounding_mode.value()) : std::nullopt)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list DivBackward2_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto other = packed_args.unpack<Tensor>();
  auto rounding_mode = packed_args.unpack<std::optional<std::string>>();
  auto self = packed_args.unpack<Tensor>();
  auto self_scalar_type = packed_args.unpack<at::ScalarType>();
  return DivBackward2_apply_functional(variable_list(grads), needs_input_grad, other, rounding_mode, self, self_scalar_type);
#endif
}

variable_list DivBackward2::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto other = other_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  return DivBackward2_apply_functional(std::move(grads), needs_input_grad, other, rounding_mode, self, self_scalar_type);
}

void DivBackward2::compiled_args(CompiledNodeArgs& args) const {
    args.collect(other_, false);
    args.collect(rounding_mode);
    args.collect(self_, false);
    args.collect(self_scalar_type);
}
variable_list DivBackward2::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(other_);
  saved.before(rounding_mode);
  saved.before(self_);
  saved.before(self_scalar_type);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::optional<std::string>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::ScalarType>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), DivBackward2_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto other = other_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(other);
  packed_args.pack(rounding_mode);
  packed_args.pack(self);
  packed_args.pack(self_scalar_type);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(other_);
  saved.after(rounding_mode);
  saved.after(self_);
  saved.after(self_scalar_type);
  return output_result;
#endif
}

static variable_list DivBackward3_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, at::Scalar& other, std::optional<std::string>& rounding_mode, at::ScalarType& self_scalar_type)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (div_tensor_self_backward(grad, other, self_scalar_type, rounding_mode.has_value() ? std::optional<std::string_view>(rounding_mode.value()) : std::nullopt)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list DivBackward3_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto other = packed_args.unpack<at::Scalar>();
  auto rounding_mode = packed_args.unpack<std::optional<std::string>>();
  auto self_scalar_type = packed_args.unpack<at::ScalarType>();
  return DivBackward3_apply_functional(variable_list(grads), needs_input_grad, other, rounding_mode, self_scalar_type);
#endif
}

variable_list DivBackward3::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return DivBackward3_apply_functional(std::move(grads), needs_input_grad, other, rounding_mode, self_scalar_type);
}

void DivBackward3::compiled_args(CompiledNodeArgs& args) const {
    args.collect(other);
    args.collect(rounding_mode);
    args.collect(self_scalar_type);
}
variable_list DivBackward3::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(other);
  saved.before(rounding_mode);
  saved.before(self_scalar_type);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::optional<std::string>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::ScalarType>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), DivBackward3_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(other);
  packed_args.pack(rounding_mode);
  packed_args.pack(self_scalar_type);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(other);
  saved.after(rounding_mode);
  saved.after(self_scalar_type);
  return output_result;
#endif
}

static variable_list DotBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& self, Tensor& tensor)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto tensor_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad * tensor.conj()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  if (needs_input_grad[/*tensor*/1]) {
    auto grad_result = any_grad_defined ? (grad * self.conj()) : Tensor();
    copy_range(grad_inputs, tensor_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list DotBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto self = packed_args.unpack<Tensor>();
  auto tensor = packed_args.unpack<Tensor>();
  return DotBackward0_apply_functional(variable_list(grads), needs_input_grad, self, tensor);
#endif
}

variable_list DotBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto tensor = tensor_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto tensor_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ tensor_ix }),
  };
  return DotBackward0_apply_functional(std::move(grads), needs_input_grad, self, tensor);
}

void DotBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
    args.collect(tensor_, false);
}
variable_list DotBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);
  saved.before(tensor_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), DotBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto tensor = tensor_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto tensor_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ tensor_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);
  packed_args.pack(tensor);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  saved.after(tensor_);
  return output_result;
#endif
}

static variable_list VdotBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& other, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*other*/1]) {
    auto grad_result = any_grad_defined ? (grad * self) : Tensor();
    copy_range(grad_inputs, other_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.conj() * other) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list VdotBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto other = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<Tensor>();
  return VdotBackward0_apply_functional(variable_list(grads), needs_input_grad, other, self);
#endif
}

variable_list VdotBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto other = other_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  return VdotBackward0_apply_functional(std::move(grads), needs_input_grad, other, self);
}

void VdotBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(other_, false);
    args.collect(self_, false);
}
variable_list VdotBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(other_);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), VdotBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto other = other_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(other);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(other_);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list FusedDropoutBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, double& p, Tensor& result1)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (_fused_dropout_backward(grad, result1, p)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list FusedDropoutBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto p = packed_args.unpack<double>();
  auto result1 = packed_args.unpack<Tensor>();
  return FusedDropoutBackward0_apply_functional(variable_list(grads), needs_input_grad, p, result1);
#endif
}

variable_list FusedDropoutBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto result1 = result1_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return FusedDropoutBackward0_apply_functional(std::move(grads), needs_input_grad, p, result1);
}

void FusedDropoutBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(p);
    args.collect(result1_, true);
}
variable_list FusedDropoutBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(p);
  saved.before(result1_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<double>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), FusedDropoutBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto result1 = result1_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(p);
  packed_args.pack(result1);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(p);
  saved.after(result1_);
  return output_result;
#endif
}

static variable_list NativeDropoutBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, double& p, ::std::optional<bool>& train, Tensor& result1)
{
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*input*/0]) {
    auto grad_result = any_grad_defined ? (GradMode::is_enabled() ? infinitely_differentiable_native_dropout_backward(grad, result1, (!train.has_value() || !train.value() ? 1 : (p == 1 ? 0.0 : 1.0 / (1.0 - p)))) : native_dropout_backward(grad, result1, (!train.has_value() || !train.value() ? 1 : (p == 1 ? 0.0 : 1.0 / (1.0 - p))))) : Tensor();
    copy_range(grad_inputs, input_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list NativeDropoutBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto p = packed_args.unpack<double>();
  auto train = packed_args.unpack<::std::optional<bool>>();
  auto result1 = packed_args.unpack<Tensor>();
  return NativeDropoutBackward0_apply_functional(variable_list(grads), needs_input_grad, p, train, result1);
#endif
}

variable_list NativeDropoutBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto result1 = result1_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ input_ix }),
  };
  return NativeDropoutBackward0_apply_functional(std::move(grads), needs_input_grad, p, train, result1);
}

void NativeDropoutBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(p);
    args.collect(train);
    args.collect(result1_, true);
}
variable_list NativeDropoutBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(p);
  saved.before(train);
  saved.before(result1_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<double>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<bool>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), NativeDropoutBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto result1 = result1_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ input_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(p);
  packed_args.pack(train);
  packed_args.pack(result1);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(p);
  saved.after(train);
  saved.after(result1_);
  return output_result;
#endif
}

static variable_list NativeDropoutBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& grad_output, Tensor& mask, double& scale)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto mask_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (native_dropout_double_backward(grad, grad_output, mask, scale)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  if (needs_input_grad[/*mask*/1]) {
    auto grad_result = not_implemented("native_dropout_backward: mask");
    copy_range(grad_inputs, mask_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list NativeDropoutBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto grad_output = packed_args.unpack<Tensor>();
  auto mask = packed_args.unpack<Tensor>();
  auto scale = packed_args.unpack<double>();
  return NativeDropoutBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, grad_output, mask, scale);
#endif
}

variable_list NativeDropoutBackwardBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto grad_output = grad_output_.unpack();
  auto mask = mask_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto mask_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ mask_ix }),
  };
  return NativeDropoutBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, grad_output, mask, scale);
}

void NativeDropoutBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(grad_output_, false);
    args.collect(mask_, false);
    args.collect(scale);
}
variable_list NativeDropoutBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(grad_output_);
  saved.before(mask_);
  saved.before(scale);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<double>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), NativeDropoutBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto grad_output = grad_output_.unpack();
  auto mask = mask_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto mask_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ mask_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(grad_output);
  packed_args.pack(mask);
  packed_args.pack(scale);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(grad_output_);
  saved.after(mask_);
  saved.after(scale);
  return output_result;
#endif
}

static variable_list EqBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, torch::autograd::generated::TypeAndSize& self_info)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (self_info.zeros()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list EqBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_info = packed_args.unpack<torch::autograd::generated::TypeAndSize>();
  return EqBackward0_apply_functional(variable_list(grads), needs_input_grad, self_info);
#endif
}

variable_list EqBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return EqBackward0_apply_functional(std::move(grads), needs_input_grad, self_info);
}

void EqBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_info);
}
variable_list EqBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_info);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::autograd::generated::TypeAndSize>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), EqBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_info);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_info);
  return output_result;
#endif
}

static variable_list EqBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, torch::autograd::generated::TypeAndSize& other_info, torch::autograd::generated::TypeAndSize& self_info)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*other*/1]) {
    auto grad_result = any_grad_defined ? (other_info.zeros()) : Tensor();
    copy_range(grad_inputs, other_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (self_info.zeros()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list EqBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto other_info = packed_args.unpack<torch::autograd::generated::TypeAndSize>();
  auto self_info = packed_args.unpack<torch::autograd::generated::TypeAndSize>();
  return EqBackward1_apply_functional(variable_list(grads), needs_input_grad, other_info, self_info);
#endif
}

variable_list EqBackward1::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  return EqBackward1_apply_functional(std::move(grads), needs_input_grad, other_info, self_info);
}

void EqBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(other_info);
    args.collect(self_info);
}
variable_list EqBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(other_info);
  saved.before(self_info);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::autograd::generated::TypeAndSize>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::autograd::generated::TypeAndSize>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), EqBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(other_info);
  packed_args.pack(self_info);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(other_info);
  saved.after(self_info);
  return output_result;
#endif
}

static variable_list ErfBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (2.0 / sqrt(M_PI) * exp(-(self.pow(2))) * grad) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ErfBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  return ErfBackward0_apply_functional(variable_list(grads), needs_input_grad, self);
#endif
}

variable_list ErfBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ErfBackward0_apply_functional(std::move(grads), needs_input_grad, self);
}

void ErfBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list ErfBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ErfBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list ErfcBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (-2.0 / sqrt(M_PI) * exp(-(self.pow(2))) * grad) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ErfcBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  return ErfcBackward0_apply_functional(variable_list(grads), needs_input_grad, self);
#endif
}

variable_list ErfcBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ErfcBackward0_apply_functional(std::move(grads), needs_input_grad, self);
}

void ErfcBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list ErfcBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ErfcBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list SpecialErfcxBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? ((2.0 * self * result - 2.0 / sqrt(M_PI)) * grad) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SpecialErfcxBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  auto result = packed_args.unpack<Tensor>();
  return SpecialErfcxBackward0_apply_functional(variable_list(grads), needs_input_grad, self, result);
#endif
}

variable_list SpecialErfcxBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SpecialErfcxBackward0_apply_functional(std::move(grads), needs_input_grad, self, result);
}

void SpecialErfcxBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
    args.collect(result_, true);
}
variable_list SpecialErfcxBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SpecialErfcxBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list ErfinvBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (0.5 * sqrt(M_PI) * exp(self.erfinv().pow(2)) * grad) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ErfinvBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  return ErfinvBackward0_apply_functional(variable_list(grads), needs_input_grad, self);
#endif
}

variable_list ErfinvBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ErfinvBackward0_apply_functional(std::move(grads), needs_input_grad, self);
}

void ErfinvBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list ErfinvBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ErfinvBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list ExpBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad * result.conj()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ExpBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto result = packed_args.unpack<Tensor>();
  return ExpBackward0_apply_functional(variable_list(grads), needs_input_grad, result);
#endif
}

variable_list ExpBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ExpBackward0_apply_functional(std::move(grads), needs_input_grad, result);
}

void ExpBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(result_, true);
}
variable_list ExpBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ExpBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(result_);
  return output_result;
#endif
}

static variable_list Exp2Backward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad * result.conj() * M_LN2) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list Exp2Backward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto result = packed_args.unpack<Tensor>();
  return Exp2Backward0_apply_functional(variable_list(grads), needs_input_grad, result);
#endif
}

variable_list Exp2Backward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return Exp2Backward0_apply_functional(std::move(grads), needs_input_grad, result);
}

void Exp2Backward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(result_, true);
}
variable_list Exp2Backward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), Exp2Backward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(result_);
  return output_result;
#endif
}

static variable_list Expm1Backward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad * (result.conj() + 1)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list Expm1Backward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto result = packed_args.unpack<Tensor>();
  return Expm1Backward0_apply_functional(variable_list(grads), needs_input_grad, result);
#endif
}

variable_list Expm1Backward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return Expm1Backward0_apply_functional(std::move(grads), needs_input_grad, result);
}

void Expm1Backward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(result_, true);
}
variable_list Expm1Backward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), Expm1Backward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(result_);
  return output_result;
#endif
}

static variable_list ExpandBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<c10::SymInt>& self_sym_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (at::sum_to(grad, self_sym_sizes)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ExpandBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return ExpandBackward0_apply_functional(variable_list(grads), needs_input_grad, self_sym_sizes);
#endif
}

variable_list ExpandBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ExpandBackward0_apply_functional(std::move(grads), needs_input_grad, self_sym_sizes);
}

void ExpandBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_sym_sizes);
}
variable_list ExpandBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ExpandBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_sym_sizes);
  return output_result;
#endif
}

static variable_list ExponentialBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (zeros_like(grad)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ExponentialBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return ExponentialBackward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list ExponentialBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ExponentialBackward0_apply_functional(std::move(grads), needs_input_grad);
}

void ExponentialBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list ExponentialBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ExponentialBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list FakeQuantizePerTensorAffineCachemaskBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& mask)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (fake_quantize_per_tensor_affine_cachemask_backward(grad, mask)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list FakeQuantizePerTensorAffineCachemaskBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto mask = packed_args.unpack<Tensor>();
  return FakeQuantizePerTensorAffineCachemaskBackward0_apply_functional(variable_list(grads), needs_input_grad, mask);
#endif
}

variable_list FakeQuantizePerTensorAffineCachemaskBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto mask = mask_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return FakeQuantizePerTensorAffineCachemaskBackward0_apply_functional(std::move(grads), needs_input_grad, mask);
}

void FakeQuantizePerTensorAffineCachemaskBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(mask_, true);
}
variable_list FakeQuantizePerTensorAffineCachemaskBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(mask_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), FakeQuantizePerTensorAffineCachemaskBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto mask = mask_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(mask);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(mask_);
  return output_result;
#endif
}

static variable_list FakeQuantizePerTensorAffineCachemaskTensorQparamsBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& mask)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (fake_quantize_per_tensor_affine_cachemask_backward(grad, mask)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list FakeQuantizePerTensorAffineCachemaskTensorQparamsBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto mask = packed_args.unpack<Tensor>();
  return FakeQuantizePerTensorAffineCachemaskTensorQparamsBackward0_apply_functional(variable_list(grads), needs_input_grad, mask);
#endif
}

variable_list FakeQuantizePerTensorAffineCachemaskTensorQparamsBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto mask = mask_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return FakeQuantizePerTensorAffineCachemaskTensorQparamsBackward0_apply_functional(std::move(grads), needs_input_grad, mask);
}

void FakeQuantizePerTensorAffineCachemaskTensorQparamsBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(mask_, true);
}
variable_list FakeQuantizePerTensorAffineCachemaskTensorQparamsBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(mask_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), FakeQuantizePerTensorAffineCachemaskTensorQparamsBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto mask = mask_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(mask);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(mask_);
  return output_result;
#endif
}

static variable_list FakeQuantizeLearnablePerTensorAffineBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, double& grad_factor, int64_t& quant_max, int64_t& quant_min, Tensor& scale, Tensor& self, Tensor& zero_point)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto scale_ix = gen.range(1);
  auto zero_point_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1] || needs_input_grad[2]) {
  
    auto grad_result = grad.defined() ? _fake_quantize_learnable_per_tensor_affine_backward(grad, self, scale, zero_point, quant_min, quant_max, grad_factor) : std::tuple<Tensor, Tensor, Tensor>();
      if (needs_input_grad[/*self*/0]) {
        copy_range(grad_inputs, self_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*scale*/1]) {
        copy_range(grad_inputs, scale_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*zero_point*/2]) {
        copy_range(grad_inputs, zero_point_ix, std::get<2>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list FakeQuantizeLearnablePerTensorAffineBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto grad_factor = packed_args.unpack<double>();
  auto quant_max = packed_args.unpack<int64_t>();
  auto quant_min = packed_args.unpack<int64_t>();
  auto scale = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<Tensor>();
  auto zero_point = packed_args.unpack<Tensor>();
  return FakeQuantizeLearnablePerTensorAffineBackward0_apply_functional(variable_list(grads), needs_input_grad, grad_factor, quant_max, quant_min, scale, self, zero_point);
#endif
}

variable_list FakeQuantizeLearnablePerTensorAffineBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto scale = scale_.unpack();
  auto self = self_.unpack();
  auto zero_point = zero_point_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto scale_ix = gen.range(1);
  auto zero_point_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ scale_ix }),
    task_should_compute_output({ zero_point_ix }),
  };
  return FakeQuantizeLearnablePerTensorAffineBackward0_apply_functional(std::move(grads), needs_input_grad, grad_factor, quant_max, quant_min, scale, self, zero_point);
}

void FakeQuantizeLearnablePerTensorAffineBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(grad_factor);
    args.collect(quant_max);
    args.collect(quant_min);
    args.collect(scale_, false);
    args.collect(self_, false);
    args.collect(zero_point_, false);
}
variable_list FakeQuantizeLearnablePerTensorAffineBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(grad_factor);
  saved.before(quant_max);
  saved.before(quant_min);
  saved.before(scale_);
  saved.before(self_);
  saved.before(zero_point_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<double>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), FakeQuantizeLearnablePerTensorAffineBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto scale = scale_.unpack();
  auto self = self_.unpack();
  auto zero_point = zero_point_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto scale_ix = gen.range(1);
  auto zero_point_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ scale_ix }),
    task_should_compute_output({ zero_point_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(grad_factor);
  packed_args.pack(quant_max);
  packed_args.pack(quant_min);
  packed_args.pack(scale);
  packed_args.pack(self);
  packed_args.pack(zero_point);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(grad_factor);
  saved.after(quant_max);
  saved.after(quant_min);
  saved.after(scale_);
  saved.after(self_);
  saved.after(zero_point_);
  return output_result;
#endif
}

static variable_list FakeQuantizePerChannelAffineCachemaskBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& mask)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (fake_quantize_per_channel_affine_cachemask_backward(grad, mask)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list FakeQuantizePerChannelAffineCachemaskBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto mask = packed_args.unpack<Tensor>();
  return FakeQuantizePerChannelAffineCachemaskBackward0_apply_functional(variable_list(grads), needs_input_grad, mask);
#endif
}

variable_list FakeQuantizePerChannelAffineCachemaskBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto mask = mask_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return FakeQuantizePerChannelAffineCachemaskBackward0_apply_functional(std::move(grads), needs_input_grad, mask);
}

void FakeQuantizePerChannelAffineCachemaskBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(mask_, true);
}
variable_list FakeQuantizePerChannelAffineCachemaskBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(mask_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), FakeQuantizePerChannelAffineCachemaskBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto mask = mask_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(mask);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(mask_);
  return output_result;
#endif
}

static variable_list FakeQuantizeLearnablePerChannelAffineBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, int64_t& axis, double& grad_factor, int64_t& quant_max, int64_t& quant_min, Tensor& scale, Tensor& self, Tensor& zero_point)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto scale_ix = gen.range(1);
  auto zero_point_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1] || needs_input_grad[2]) {
  
    auto grad_result = grad.defined() ? _fake_quantize_learnable_per_channel_affine_backward(grad, self, scale, zero_point, axis, quant_min, quant_max, grad_factor) : std::tuple<Tensor, Tensor, Tensor>();
      if (needs_input_grad[/*self*/0]) {
        copy_range(grad_inputs, self_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*scale*/1]) {
        copy_range(grad_inputs, scale_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*zero_point*/2]) {
        copy_range(grad_inputs, zero_point_ix, std::get<2>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list FakeQuantizeLearnablePerChannelAffineBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto axis = packed_args.unpack<int64_t>();
  auto grad_factor = packed_args.unpack<double>();
  auto quant_max = packed_args.unpack<int64_t>();
  auto quant_min = packed_args.unpack<int64_t>();
  auto scale = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<Tensor>();
  auto zero_point = packed_args.unpack<Tensor>();
  return FakeQuantizeLearnablePerChannelAffineBackward0_apply_functional(variable_list(grads), needs_input_grad, axis, grad_factor, quant_max, quant_min, scale, self, zero_point);
#endif
}

variable_list FakeQuantizeLearnablePerChannelAffineBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto scale = scale_.unpack();
  auto self = self_.unpack();
  auto zero_point = zero_point_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto scale_ix = gen.range(1);
  auto zero_point_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ scale_ix }),
    task_should_compute_output({ zero_point_ix }),
  };
  return FakeQuantizeLearnablePerChannelAffineBackward0_apply_functional(std::move(grads), needs_input_grad, axis, grad_factor, quant_max, quant_min, scale, self, zero_point);
}

void FakeQuantizeLearnablePerChannelAffineBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(axis);
    args.collect(grad_factor);
    args.collect(quant_max);
    args.collect(quant_min);
    args.collect(scale_, false);
    args.collect(self_, false);
    args.collect(zero_point_, false);
}
variable_list FakeQuantizeLearnablePerChannelAffineBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(axis);
  saved.before(grad_factor);
  saved.before(quant_max);
  saved.before(quant_min);
  saved.before(scale_);
  saved.before(self_);
  saved.before(zero_point_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<double>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), FakeQuantizeLearnablePerChannelAffineBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto scale = scale_.unpack();
  auto self = self_.unpack();
  auto zero_point = zero_point_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto scale_ix = gen.range(1);
  auto zero_point_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ scale_ix }),
    task_should_compute_output({ zero_point_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(axis);
  packed_args.pack(grad_factor);
  packed_args.pack(quant_max);
  packed_args.pack(quant_min);
  packed_args.pack(scale);
  packed_args.pack(self);
  packed_args.pack(zero_point);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(axis);
  saved.after(grad_factor);
  saved.after(quant_max);
  saved.after(quant_min);
  saved.after(scale_);
  saved.after(self_);
  saved.after(zero_point_);
  return output_result;
#endif
}

static variable_list FusedMovingAvgObsFqHelperBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& mask)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (fake_quantize_per_tensor_affine_cachemask_backward(grad, mask)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list FusedMovingAvgObsFqHelperBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto mask = packed_args.unpack<Tensor>();
  return FusedMovingAvgObsFqHelperBackward0_apply_functional(variable_list(grads), needs_input_grad, mask);
#endif
}

variable_list FusedMovingAvgObsFqHelperBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto mask = mask_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return FusedMovingAvgObsFqHelperBackward0_apply_functional(std::move(grads), needs_input_grad, mask);
}

void FusedMovingAvgObsFqHelperBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(mask_, true);
}
variable_list FusedMovingAvgObsFqHelperBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(mask_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), FusedMovingAvgObsFqHelperBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto mask = mask_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(mask);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(mask_);
  return output_result;
#endif
}

static variable_list FillBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (zeros_like(grad)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list FillBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return FillBackward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list FillBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return FillBackward0_apply_functional(std::move(grads), needs_input_grad);
}

void FillBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list FillBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), FillBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list FillBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto value_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (zeros_like(grad)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  if (needs_input_grad[/*value*/1]) {
    auto grad_result = any_grad_defined ? (grad.sum()) : Tensor();
    copy_range(grad_inputs, value_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list FillBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();

  return FillBackward1_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list FillBackward1::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto value_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ value_ix }),
  };
  return FillBackward1_apply_functional(std::move(grads), needs_input_grad);
}

void FillBackward1::compiled_args(CompiledNodeArgs& args) const {

}
variable_list FillBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), FillBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto value_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ value_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list FillBackward2_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (zeros_like(grad)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list FillBackward2_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return FillBackward2_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list FillBackward2::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return FillBackward2_apply_functional(std::move(grads), needs_input_grad);
}

void FillBackward2::compiled_args(CompiledNodeArgs& args) const {

}
variable_list FillBackward2::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), FillBackward2_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list FillBackward3_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto value_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (zeros_like(grad)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  if (needs_input_grad[/*value*/1]) {
    auto grad_result = any_grad_defined ? (grad.sum()) : Tensor();
    copy_range(grad_inputs, value_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list FillBackward3_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();

  return FillBackward3_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list FillBackward3::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto value_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ value_ix }),
  };
  return FillBackward3_apply_functional(std::move(grads), needs_input_grad);
}

void FillBackward3::compiled_args(CompiledNodeArgs& args) const {

}
variable_list FillBackward3::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), FillBackward3_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto value_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ value_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list FloorBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (zeros_like(grad)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list FloorBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return FloorBackward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list FloorBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return FloorBackward0_apply_functional(std::move(grads), needs_input_grad);
}

void FloorBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list FloorBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), FloorBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list FmodBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list FmodBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return FmodBackward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list FmodBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return FmodBackward0_apply_functional(std::move(grads), needs_input_grad);
}

void FmodBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list FmodBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), FmodBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list FmodBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& other, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*other*/1]) {
    auto grad_result = any_grad_defined ? (-grad * self.div(other, /*rounding_mode=*/"trunc")) : Tensor();
    copy_range(grad_inputs, other_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list FmodBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto other = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<Tensor>();
  return FmodBackward1_apply_functional(variable_list(grads), needs_input_grad, other, self);
#endif
}

variable_list FmodBackward1::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto other = other_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  return FmodBackward1_apply_functional(std::move(grads), needs_input_grad, other, self);
}

void FmodBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(other_, false);
    args.collect(self_, false);
}
variable_list FmodBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(other_);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), FmodBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto other = other_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(other);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(other_);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list FracBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list FracBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return FracBackward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list FracBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return FracBackward0_apply_functional(std::move(grads), needs_input_grad);
}

void FracBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list FracBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), FracBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list FrexpBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& exponent)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad / exponent.exp2()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list FrexpBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto exponent = packed_args.unpack<Tensor>();
  return FrexpBackward0_apply_functional(variable_list(grads), needs_input_grad, exponent);
#endif
}

variable_list FrexpBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto exponent = exponent_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return FrexpBackward0_apply_functional(std::move(grads), needs_input_grad, exponent);
}

void FrexpBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(exponent_, true);
}
variable_list FrexpBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(exponent_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), FrexpBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto exponent = exponent_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(exponent);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(exponent_);
  return output_result;
#endif
}

static variable_list GatherBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim, Tensor& index, Tensor& self, bool& sparse_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (gather_backward(grad, self, dim, index, sparse_grad)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list GatherBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  auto index = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<Tensor>();
  auto sparse_grad = packed_args.unpack<bool>();
  return GatherBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, index, self, sparse_grad);
#endif
}

variable_list GatherBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto index = index_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return GatherBackward0_apply_functional(std::move(grads), needs_input_grad, dim, index, self, sparse_grad);
}

void GatherBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(index_, false);
    args.collect(self_, false);
    args.collect(sparse_grad);
}
variable_list GatherBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(index_);
  saved.before(self_);
  saved.before(sparse_grad);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), GatherBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto index = index_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(index);
  packed_args.pack(self);
  packed_args.pack(sparse_grad);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(index_);
  saved.after(self_);
  saved.after(sparse_grad);
  return output_result;
#endif
}

static variable_list GeBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, torch::autograd::generated::TypeAndSize& self_info)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (self_info.zeros()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list GeBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_info = packed_args.unpack<torch::autograd::generated::TypeAndSize>();
  return GeBackward0_apply_functional(variable_list(grads), needs_input_grad, self_info);
#endif
}

variable_list GeBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return GeBackward0_apply_functional(std::move(grads), needs_input_grad, self_info);
}

void GeBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_info);
}
variable_list GeBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_info);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::autograd::generated::TypeAndSize>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), GeBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_info);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_info);
  return output_result;
#endif
}

static variable_list GeBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, torch::autograd::generated::TypeAndSize& other_info, torch::autograd::generated::TypeAndSize& self_info)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*other*/1]) {
    auto grad_result = any_grad_defined ? (other_info.zeros()) : Tensor();
    copy_range(grad_inputs, other_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (self_info.zeros()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list GeBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto other_info = packed_args.unpack<torch::autograd::generated::TypeAndSize>();
  auto self_info = packed_args.unpack<torch::autograd::generated::TypeAndSize>();
  return GeBackward1_apply_functional(variable_list(grads), needs_input_grad, other_info, self_info);
#endif
}

variable_list GeBackward1::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  return GeBackward1_apply_functional(std::move(grads), needs_input_grad, other_info, self_info);
}

void GeBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(other_info);
    args.collect(self_info);
}
variable_list GeBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(other_info);
  saved.before(self_info);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::autograd::generated::TypeAndSize>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::autograd::generated::TypeAndSize>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), GeBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(other_info);
  packed_args.pack(self_info);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(other_info);
  saved.after(self_info);
  return output_result;
#endif
}

static variable_list GeometricBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (zeros_like(grad)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list GeometricBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return GeometricBackward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list GeometricBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return GeometricBackward0_apply_functional(std::move(grads), needs_input_grad);
}

void GeometricBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list GeometricBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), GeometricBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list GeqrfBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = not_implemented("geqrf");
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list GeqrfBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return GeqrfBackward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list GeqrfBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return GeqrfBackward0_apply_functional(std::move(grads), needs_input_grad);
}

void GeqrfBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list GeqrfBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), GeqrfBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list GridSampler2DBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, bool& align_corners, Tensor& grid, Tensor& input, int64_t& interpolation_mode, int64_t& padding_mode)
{
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto grid_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1]) {
      auto grad_input_mask = std::array<bool, 2>{
        needs_input_grad[0],
        needs_input_grad[1],
      };
    auto grad_result = grad.defined() ? grid_sampler_2d_backward(grad, input, grid, interpolation_mode, padding_mode, align_corners, grad_input_mask) : std::tuple<Tensor, Tensor>();
      if (needs_input_grad[/*input*/0]) {
        copy_range(grad_inputs, input_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*grid*/1]) {
        copy_range(grad_inputs, grid_ix, std::get<1>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list GridSampler2DBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto align_corners = packed_args.unpack<bool>();
  auto grid = packed_args.unpack<Tensor>();
  auto input = packed_args.unpack<Tensor>();
  auto interpolation_mode = packed_args.unpack<int64_t>();
  auto padding_mode = packed_args.unpack<int64_t>();
  return GridSampler2DBackward0_apply_functional(variable_list(grads), needs_input_grad, align_corners, grid, input, interpolation_mode, padding_mode);
#endif
}

variable_list GridSampler2DBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto grid = grid_.unpack();
  auto input = input_.unpack();
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto grid_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ grid_ix }),
  };
  return GridSampler2DBackward0_apply_functional(std::move(grads), needs_input_grad, align_corners, grid, input, interpolation_mode, padding_mode);
}

void GridSampler2DBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(align_corners);
    args.collect(grid_, false);
    args.collect(input_, false);
    args.collect(interpolation_mode);
    args.collect(padding_mode);
}
variable_list GridSampler2DBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(align_corners);
  saved.before(grid_);
  saved.before(input_);
  saved.before(interpolation_mode);
  saved.before(padding_mode);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), GridSampler2DBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto grid = grid_.unpack();
  auto input = input_.unpack();
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto grid_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ grid_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(align_corners);
  packed_args.pack(grid);
  packed_args.pack(input);
  packed_args.pack(interpolation_mode);
  packed_args.pack(padding_mode);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(align_corners);
  saved.after(grid_);
  saved.after(input_);
  saved.after(interpolation_mode);
  saved.after(padding_mode);
  return output_result;
#endif
}

static variable_list GridSampler3DBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, bool& align_corners, Tensor& grid, Tensor& input, int64_t& interpolation_mode, int64_t& padding_mode)
{
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto grid_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1]) {
      auto grad_input_mask = std::array<bool, 2>{
        needs_input_grad[0],
        needs_input_grad[1],
      };
    auto grad_result = grad.defined() ? grid_sampler_3d_backward(grad, input, grid, interpolation_mode, padding_mode, align_corners, grad_input_mask) : std::tuple<Tensor, Tensor>();
      if (needs_input_grad[/*input*/0]) {
        copy_range(grad_inputs, input_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*grid*/1]) {
        copy_range(grad_inputs, grid_ix, std::get<1>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list GridSampler3DBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto align_corners = packed_args.unpack<bool>();
  auto grid = packed_args.unpack<Tensor>();
  auto input = packed_args.unpack<Tensor>();
  auto interpolation_mode = packed_args.unpack<int64_t>();
  auto padding_mode = packed_args.unpack<int64_t>();
  return GridSampler3DBackward0_apply_functional(variable_list(grads), needs_input_grad, align_corners, grid, input, interpolation_mode, padding_mode);
#endif
}

variable_list GridSampler3DBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto grid = grid_.unpack();
  auto input = input_.unpack();
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto grid_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ grid_ix }),
  };
  return GridSampler3DBackward0_apply_functional(std::move(grads), needs_input_grad, align_corners, grid, input, interpolation_mode, padding_mode);
}

void GridSampler3DBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(align_corners);
    args.collect(grid_, false);
    args.collect(input_, false);
    args.collect(interpolation_mode);
    args.collect(padding_mode);
}
variable_list GridSampler3DBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(align_corners);
  saved.before(grid_);
  saved.before(input_);
  saved.before(interpolation_mode);
  saved.before(padding_mode);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), GridSampler3DBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto grid = grid_.unpack();
  auto input = input_.unpack();
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto grid_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ grid_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(align_corners);
  packed_args.pack(grid);
  packed_args.pack(input);
  packed_args.pack(interpolation_mode);
  packed_args.pack(padding_mode);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(align_corners);
  saved.after(grid_);
  saved.after(input_);
  saved.after(interpolation_mode);
  saved.after(padding_mode);
  return output_result;
#endif
}

static variable_list GridSampler2DCpuFallbackBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, bool& align_corners, Tensor& grid, Tensor& input, int64_t& interpolation_mode, int64_t& padding_mode)
{
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto grid_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1]) {
  
    auto grad_result = grad.defined() ? _grid_sampler_2d_cpu_fallback_backward(grad, input, grid, interpolation_mode, padding_mode, align_corners) : std::tuple<Tensor, Tensor>();
      if (needs_input_grad[/*input*/0]) {
        copy_range(grad_inputs, input_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*grid*/1]) {
        copy_range(grad_inputs, grid_ix, std::get<1>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list GridSampler2DCpuFallbackBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto align_corners = packed_args.unpack<bool>();
  auto grid = packed_args.unpack<Tensor>();
  auto input = packed_args.unpack<Tensor>();
  auto interpolation_mode = packed_args.unpack<int64_t>();
  auto padding_mode = packed_args.unpack<int64_t>();
  return GridSampler2DCpuFallbackBackward0_apply_functional(variable_list(grads), needs_input_grad, align_corners, grid, input, interpolation_mode, padding_mode);
#endif
}

variable_list GridSampler2DCpuFallbackBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto grid = grid_.unpack();
  auto input = input_.unpack();
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto grid_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ grid_ix }),
  };
  return GridSampler2DCpuFallbackBackward0_apply_functional(std::move(grads), needs_input_grad, align_corners, grid, input, interpolation_mode, padding_mode);
}

void GridSampler2DCpuFallbackBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(align_corners);
    args.collect(grid_, false);
    args.collect(input_, false);
    args.collect(interpolation_mode);
    args.collect(padding_mode);
}
variable_list GridSampler2DCpuFallbackBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(align_corners);
  saved.before(grid_);
  saved.before(input_);
  saved.before(interpolation_mode);
  saved.before(padding_mode);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), GridSampler2DCpuFallbackBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto grid = grid_.unpack();
  auto input = input_.unpack();
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto grid_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ grid_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(align_corners);
  packed_args.pack(grid);
  packed_args.pack(input);
  packed_args.pack(interpolation_mode);
  packed_args.pack(padding_mode);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(align_corners);
  saved.after(grid_);
  saved.after(input_);
  saved.after(interpolation_mode);
  saved.after(padding_mode);
  return output_result;
#endif
}

static variable_list GtBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, torch::autograd::generated::TypeAndSize& self_info)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (self_info.zeros()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list GtBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_info = packed_args.unpack<torch::autograd::generated::TypeAndSize>();
  return GtBackward0_apply_functional(variable_list(grads), needs_input_grad, self_info);
#endif
}

variable_list GtBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return GtBackward0_apply_functional(std::move(grads), needs_input_grad, self_info);
}

void GtBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_info);
}
variable_list GtBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_info);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::autograd::generated::TypeAndSize>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), GtBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_info);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_info);
  return output_result;
#endif
}

static variable_list GtBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, torch::autograd::generated::TypeAndSize& other_info, torch::autograd::generated::TypeAndSize& self_info)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*other*/1]) {
    auto grad_result = any_grad_defined ? (other_info.zeros()) : Tensor();
    copy_range(grad_inputs, other_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (self_info.zeros()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list GtBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto other_info = packed_args.unpack<torch::autograd::generated::TypeAndSize>();
  auto self_info = packed_args.unpack<torch::autograd::generated::TypeAndSize>();
  return GtBackward1_apply_functional(variable_list(grads), needs_input_grad, other_info, self_info);
#endif
}

variable_list GtBackward1::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  return GtBackward1_apply_functional(std::move(grads), needs_input_grad, other_info, self_info);
}

void GtBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(other_info);
    args.collect(self_info);
}
variable_list GtBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(other_info);
  saved.before(self_info);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::autograd::generated::TypeAndSize>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::autograd::generated::TypeAndSize>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), GtBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(other_info);
  packed_args.pack(self_info);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(other_info);
  saved.after(self_info);
  return output_result;
#endif
}

static variable_list HardsigmoidBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (hardsigmoid_backward(grad, self)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list HardsigmoidBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  return HardsigmoidBackward0_apply_functional(variable_list(grads), needs_input_grad, self);
#endif
}

variable_list HardsigmoidBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return HardsigmoidBackward0_apply_functional(std::move(grads), needs_input_grad, self);
}

void HardsigmoidBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list HardsigmoidBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), HardsigmoidBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list HardswishBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (hardswish_backward(grad, self)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list HardswishBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  return HardswishBackward0_apply_functional(variable_list(grads), needs_input_grad, self);
#endif
}

variable_list HardswishBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return HardswishBackward0_apply_functional(std::move(grads), needs_input_grad, self);
}

void HardswishBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list HardswishBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), HardswishBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list HardswishBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& grad_output, Tensor& self, at::TensorOptions& self_options)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (hardswish_backward(grad, self)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  if (needs_input_grad[/*self*/1]) {
    auto grad_result = any_grad_defined ? (at::where(at::logical_and(-3.0 < self, self < 3.0), grad * grad_output / 3.0, at::zeros({}, self_options))) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list HardswishBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto grad_output = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<Tensor>();
  auto self_options = packed_args.unpack<at::TensorOptions>();
  return HardswishBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, grad_output, self, self_options);
#endif
}

variable_list HardswishBackwardBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto grad_output = grad_output_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  return HardswishBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, grad_output, self, self_options);
}

void HardswishBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(grad_output_, false);
    args.collect(self_, false);
    args.collect(self_options);
}
variable_list HardswishBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(grad_output_);
  saved.before(self_);
  saved.before(self_options);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::TensorOptions>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), HardswishBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto grad_output = grad_output_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(grad_output);
  packed_args.pack(self);
  packed_args.pack(self_options);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(grad_output_);
  saved.after(self_);
  saved.after(self_options);
  return output_result;
#endif
}

static variable_list HypotBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& other, Tensor& self, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*other*/1]) {
    auto grad_result = any_grad_defined ? (grad * other / result) : Tensor();
    copy_range(grad_inputs, other_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad * self / result) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list HypotBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto other = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<Tensor>();
  auto result = packed_args.unpack<Tensor>();
  return HypotBackward0_apply_functional(variable_list(grads), needs_input_grad, other, self, result);
#endif
}

variable_list HypotBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto other = other_.unpack();
  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  return HypotBackward0_apply_functional(std::move(grads), needs_input_grad, other, self, result);
}

void HypotBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(other_, false);
    args.collect(self_, false);
    args.collect(result_, true);
}
variable_list HypotBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(other_);
  saved.before(self_);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), HypotBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto other = other_.unpack();
  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(other);
  packed_args.pack(self);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(other_);
  saved.after(self_);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list I0Backward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad * at::special_i1(self)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list I0Backward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  return I0Backward0_apply_functional(variable_list(grads), needs_input_grad, self);
#endif
}

variable_list I0Backward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return I0Backward0_apply_functional(std::move(grads), needs_input_grad, self);
}

void I0Backward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list I0Backward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), I0Backward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list SpecialI0EBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad * (at::special_i1e(self) - self.sgn() * result)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SpecialI0EBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  auto result = packed_args.unpack<Tensor>();
  return SpecialI0EBackward0_apply_functional(variable_list(grads), needs_input_grad, self, result);
#endif
}

variable_list SpecialI0EBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SpecialI0EBackward0_apply_functional(std::move(grads), needs_input_grad, self, result);
}

void SpecialI0EBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
    args.collect(result_, true);
}
variable_list SpecialI0EBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SpecialI0EBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list SpecialI1Backward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (i1_backward(grad, self, result)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SpecialI1Backward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  auto result = packed_args.unpack<Tensor>();
  return SpecialI1Backward0_apply_functional(variable_list(grads), needs_input_grad, self, result);
#endif
}

variable_list SpecialI1Backward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SpecialI1Backward0_apply_functional(std::move(grads), needs_input_grad, self, result);
}

void SpecialI1Backward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
    args.collect(result_, true);
}
variable_list SpecialI1Backward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SpecialI1Backward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list SpecialI1EBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (i1e_backward(grad, self, result)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SpecialI1EBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  auto result = packed_args.unpack<Tensor>();
  return SpecialI1EBackward0_apply_functional(variable_list(grads), needs_input_grad, self, result);
#endif
}

variable_list SpecialI1EBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SpecialI1EBackward0_apply_functional(std::move(grads), needs_input_grad, self, result);
}

void SpecialI1EBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
    args.collect(result_, true);
}
variable_list SpecialI1EBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SpecialI1EBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list IgammaBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& other, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*other*/1]) {
    auto grad_result = any_grad_defined ? (grad * exp((self - 1) * log(other) - other - lgamma(self))) : Tensor();
    copy_range(grad_inputs, other_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = not_implemented("igamma: input");
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list IgammaBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto other = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<Tensor>();
  return IgammaBackward0_apply_functional(variable_list(grads), needs_input_grad, other, self);
#endif
}

variable_list IgammaBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto other = other_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  return IgammaBackward0_apply_functional(std::move(grads), needs_input_grad, other, self);
}

void IgammaBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(other_, false);
    args.collect(self_, false);
}
variable_list IgammaBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(other_);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), IgammaBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto other = other_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(other);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(other_);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list IgammacBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& other, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*other*/1]) {
    auto grad_result = any_grad_defined ? (-grad * exp((self - 1) * log(other) - other - lgamma(self))) : Tensor();
    copy_range(grad_inputs, other_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = not_implemented("igammac: input");
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list IgammacBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto other = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<Tensor>();
  return IgammacBackward0_apply_functional(variable_list(grads), needs_input_grad, other, self);
#endif
}

variable_list IgammacBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto other = other_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  return IgammacBackward0_apply_functional(std::move(grads), needs_input_grad, other, self);
}

void IgammacBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(other_, false);
    args.collect(self_, false);
}
variable_list IgammacBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(other_);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), IgammacBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto other = other_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(other);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(other_);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list IndexBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, torch::List<std::optional<Tensor>>& indices, at::TensorOptions& self_options, std::vector<c10::SymInt>& self_sym_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (index_backward(grad.new_zeros_symint(self_sym_sizes, self_options), indices, grad)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list IndexBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto indices = packed_args.unpack<torch::List<std::optional<Tensor>>>();
  auto self_options = packed_args.unpack<at::TensorOptions>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return IndexBackward0_apply_functional(variable_list(grads), needs_input_grad, indices, self_options, self_sym_sizes);
#endif
}

variable_list IndexBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!indices_released_, ERR_BACKWARD_TWICE);
  auto indices = unpack_opt_list(indices_);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return IndexBackward0_apply_functional(std::move(grads), needs_input_grad, indices, self_options, self_sym_sizes);
}

void IndexBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(indices_, false);
    args.collect(self_options);
    args.collect(self_sym_sizes);
}
variable_list IndexBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(indices_);
  saved.before(self_options);
  saved.before(self_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::List<std::optional<Tensor>>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::TensorOptions>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), IndexBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!indices_released_, ERR_BACKWARD_TWICE);
  auto indices = unpack_opt_list(indices_);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(indices);
  packed_args.pack(self_options);
  packed_args.pack(self_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(indices_);
  saved.after(self_options);
  saved.after(self_sym_sizes);
  return output_result;
#endif
}

static variable_list UnsafeIndexBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, torch::List<std::optional<Tensor>>& indices, at::TensorOptions& self_options, std::vector<c10::SymInt>& self_sym_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (at::_unsafe_index_put(grad.new_zeros_symint(self_sym_sizes, self_options), indices, grad, true)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list UnsafeIndexBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto indices = packed_args.unpack<torch::List<std::optional<Tensor>>>();
  auto self_options = packed_args.unpack<at::TensorOptions>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return UnsafeIndexBackward0_apply_functional(variable_list(grads), needs_input_grad, indices, self_options, self_sym_sizes);
#endif
}

variable_list UnsafeIndexBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!indices_released_, ERR_BACKWARD_TWICE);
  auto indices = unpack_opt_list(indices_);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return UnsafeIndexBackward0_apply_functional(std::move(grads), needs_input_grad, indices, self_options, self_sym_sizes);
}

void UnsafeIndexBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(indices_, false);
    args.collect(self_options);
    args.collect(self_sym_sizes);
}
variable_list UnsafeIndexBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(indices_);
  saved.before(self_options);
  saved.before(self_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::List<std::optional<Tensor>>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::TensorOptions>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), UnsafeIndexBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!indices_released_, ERR_BACKWARD_TWICE);
  auto indices = unpack_opt_list(indices_);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(indices);
  packed_args.pack(self_options);
  packed_args.pack(self_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(indices_);
  saved.after(self_options);
  saved.after(self_sym_sizes);
  return output_result;
#endif
}

static variable_list UnsafeMaskedIndexBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, torch::List<std::optional<Tensor>>& indices, Tensor& mask, at::TensorOptions& self_options, std::vector<c10::SymInt>& self_sym_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (at::_unsafe_masked_index_put_accumulate(grad.new_zeros_symint(self_sym_sizes, self_options), mask, indices, grad)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list UnsafeMaskedIndexBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto indices = packed_args.unpack<torch::List<std::optional<Tensor>>>();
  auto mask = packed_args.unpack<Tensor>();
  auto self_options = packed_args.unpack<at::TensorOptions>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return UnsafeMaskedIndexBackward0_apply_functional(variable_list(grads), needs_input_grad, indices, mask, self_options, self_sym_sizes);
#endif
}

variable_list UnsafeMaskedIndexBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!indices_released_, ERR_BACKWARD_TWICE);
  auto indices = unpack_opt_list(indices_);
  auto mask = mask_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return UnsafeMaskedIndexBackward0_apply_functional(std::move(grads), needs_input_grad, indices, mask, self_options, self_sym_sizes);
}

void UnsafeMaskedIndexBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(indices_, false);
    args.collect(mask_, false);
    args.collect(self_options);
    args.collect(self_sym_sizes);
}
variable_list UnsafeMaskedIndexBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(indices_);
  saved.before(mask_);
  saved.before(self_options);
  saved.before(self_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::List<std::optional<Tensor>>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::TensorOptions>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), UnsafeMaskedIndexBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!indices_released_, ERR_BACKWARD_TWICE);
  auto indices = unpack_opt_list(indices_);
  auto mask = mask_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(indices);
  packed_args.pack(mask);
  packed_args.pack(self_options);
  packed_args.pack(self_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(indices_);
  saved.after(mask_);
  saved.after(self_options);
  saved.after(self_sym_sizes);
  return output_result;
#endif
}

static variable_list UnsafeMaskedIndexPutAccumulateBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, torch::List<std::optional<Tensor>>& indices, Tensor& mask)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto values_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  if (needs_input_grad[/*values*/1]) {
    auto grad_result = any_grad_defined ? (at::_unsafe_masked_index(grad, mask, indices, 0)) : Tensor();
    copy_range(grad_inputs, values_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list UnsafeMaskedIndexPutAccumulateBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto indices = packed_args.unpack<torch::List<std::optional<Tensor>>>();
  auto mask = packed_args.unpack<Tensor>();
  return UnsafeMaskedIndexPutAccumulateBackward0_apply_functional(variable_list(grads), needs_input_grad, indices, mask);
#endif
}

variable_list UnsafeMaskedIndexPutAccumulateBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!indices_released_, ERR_BACKWARD_TWICE);
  auto indices = unpack_opt_list(indices_);
  auto mask = mask_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto values_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ values_ix }),
  };
  return UnsafeMaskedIndexPutAccumulateBackward0_apply_functional(std::move(grads), needs_input_grad, indices, mask);
}

void UnsafeMaskedIndexPutAccumulateBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(indices_, false);
    args.collect(mask_, false);
}
variable_list UnsafeMaskedIndexPutAccumulateBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(indices_);
  saved.before(mask_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::List<std::optional<Tensor>>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), UnsafeMaskedIndexPutAccumulateBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!indices_released_, ERR_BACKWARD_TWICE);
  auto indices = unpack_opt_list(indices_);
  auto mask = mask_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto values_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ values_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(indices);
  packed_args.pack(mask);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(indices_);
  saved.after(mask_);
  return output_result;
#endif
}

static variable_list IndexAddBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, at::Scalar& alpha, int64_t& dim, Tensor& index, Tensor& source, int64_t& source_dim)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto source_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  if (needs_input_grad[/*source*/1]) {
    auto grad_result = any_grad_defined ? (maybe_multiply(source_dim > 0 ? grad.index_select(dim, index).expand_as(source) : grad.index_select(dim, index.squeeze(0)), alpha)) : Tensor();
    copy_range(grad_inputs, source_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list IndexAddBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto alpha = packed_args.unpack<at::Scalar>();
  auto dim = packed_args.unpack<int64_t>();
  auto index = packed_args.unpack<Tensor>();
  auto source = packed_args.unpack<Tensor>();
  auto source_dim = packed_args.unpack<int64_t>();
  return IndexAddBackward0_apply_functional(variable_list(grads), needs_input_grad, alpha, dim, index, source, source_dim);
#endif
}

variable_list IndexAddBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto index = index_.unpack();
  auto source = source_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto source_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ source_ix }),
  };
  return IndexAddBackward0_apply_functional(std::move(grads), needs_input_grad, alpha, dim, index, source, source_dim);
}

void IndexAddBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(alpha);
    args.collect(dim);
    args.collect(index_, false);
    args.collect(source_, false);
    args.collect(source_dim);
}
variable_list IndexAddBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(alpha);
  saved.before(dim);
  saved.before(index_);
  saved.before(source_);
  saved.before(source_dim);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), IndexAddBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto index = index_.unpack();
  auto source = source_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto source_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ source_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(alpha);
  packed_args.pack(dim);
  packed_args.pack(index);
  packed_args.pack(source);
  packed_args.pack(source_dim);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(alpha);
  saved.after(dim);
  saved.after(index_);
  saved.after(source_);
  saved.after(source_dim);
  return output_result;
#endif
}

static variable_list IndexReduceBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, int64_t& dim, bool& include_self, Tensor& index, std::string& reduce, Tensor& self, Tensor& source, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto source_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1]) {
  
    auto grad_result = index_reduce_backward(grad, self, dim, index, source, reduce, include_self, result);
      if (needs_input_grad[/*self*/0]) {
        copy_range(grad_inputs, self_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*source*/1]) {
        copy_range(grad_inputs, source_ix, std::get<1>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list IndexReduceBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto dim = packed_args.unpack<int64_t>();
  auto include_self = packed_args.unpack<bool>();
  auto index = packed_args.unpack<Tensor>();
  auto reduce = packed_args.unpack<std::string>();
  auto self = packed_args.unpack<Tensor>();
  auto source = packed_args.unpack<Tensor>();
  auto result = packed_args.unpack<Tensor>();
  return IndexReduceBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, include_self, index, reduce, self, source, result);
#endif
}

variable_list IndexReduceBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto index = index_.unpack();
  auto self = self_.unpack();
  auto source = source_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto source_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ source_ix }),
  };
  return IndexReduceBackward0_apply_functional(std::move(grads), needs_input_grad, dim, include_self, index, reduce, self, source, result);
}

void IndexReduceBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(include_self);
    args.collect(index_, false);
    args.collect(reduce);
    args.collect(self_, false);
    args.collect(source_, false);
    args.collect(result_, true);
}
variable_list IndexReduceBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(include_self);
  saved.before(index_);
  saved.before(reduce);
  saved.before(self_);
  saved.before(source_);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::string>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), IndexReduceBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto index = index_.unpack();
  auto self = self_.unpack();
  auto source = source_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto source_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ source_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(include_self);
  packed_args.pack(index);
  packed_args.pack(reduce);
  packed_args.pack(self);
  packed_args.pack(source);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(include_self);
  saved.after(index_);
  saved.after(reduce);
  saved.after(self_);
  saved.after(source_);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list IndexCopyBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, int64_t& dim, Tensor& index, Tensor& source, int64_t& source_dim)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto source_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.index_fill(dim, index, 0)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  if (needs_input_grad[/*source*/1]) {
    auto grad_result = any_grad_defined ? (source_dim > 0 ? grad.index_select(dim, index).expand_as(source) : grad.index_select(dim, index.squeeze(0))) : Tensor();
    copy_range(grad_inputs, source_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list IndexCopyBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto dim = packed_args.unpack<int64_t>();
  auto index = packed_args.unpack<Tensor>();
  auto source = packed_args.unpack<Tensor>();
  auto source_dim = packed_args.unpack<int64_t>();
  return IndexCopyBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, index, source, source_dim);
#endif
}

variable_list IndexCopyBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto index = index_.unpack();
  auto source = source_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto source_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ source_ix }),
  };
  return IndexCopyBackward0_apply_functional(std::move(grads), needs_input_grad, dim, index, source, source_dim);
}

void IndexCopyBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(index_, false);
    args.collect(source_, false);
    args.collect(source_dim);
}
variable_list IndexCopyBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(index_);
  saved.before(source_);
  saved.before(source_dim);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), IndexCopyBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto index = index_.unpack();
  auto source = source_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto source_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ source_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(index);
  packed_args.pack(source);
  packed_args.pack(source_dim);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(index_);
  saved.after(source_);
  saved.after(source_dim);
  return output_result;
#endif
}

static variable_list IndexFillBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim, Tensor& index)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.index_fill(dim, index, 0)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list IndexFillBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  auto index = packed_args.unpack<Tensor>();
  return IndexFillBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, index);
#endif
}

variable_list IndexFillBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto index = index_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return IndexFillBackward0_apply_functional(std::move(grads), needs_input_grad, dim, index);
}

void IndexFillBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(index_, false);
}
variable_list IndexFillBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(index_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), IndexFillBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto index = index_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(index);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(index_);
  return output_result;
#endif
}

static variable_list IndexFillBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, int64_t& dim, Tensor& index)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto value_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.index_fill(dim, index, 0)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  if (needs_input_grad[/*value*/1]) {
    auto grad_result = any_grad_defined ? (grad.index_select(dim, std::get<0>(at::_unique(index, /*sorted=*/false))).sum()) : Tensor();
    copy_range(grad_inputs, value_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list IndexFillBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto dim = packed_args.unpack<int64_t>();
  auto index = packed_args.unpack<Tensor>();
  return IndexFillBackward1_apply_functional(variable_list(grads), needs_input_grad, dim, index);
#endif
}

variable_list IndexFillBackward1::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto index = index_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto value_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ value_ix }),
  };
  return IndexFillBackward1_apply_functional(std::move(grads), needs_input_grad, dim, index);
}

void IndexFillBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(index_, false);
}
variable_list IndexFillBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(index_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), IndexFillBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto index = index_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto value_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ value_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(index);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(index_);
  return output_result;
#endif
}

static variable_list IndexPutBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, bool& accumulate, torch::List<std::optional<Tensor>>& indices, torch::autograd::generated::TypeAndSize& values_info)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto values_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (accumulate ? grad : grad.index_put(indices, values_info.zeros(), false)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  if (needs_input_grad[/*values*/1]) {
    auto grad_result = any_grad_defined ? (grad.index(indices)) : Tensor();
    copy_range(grad_inputs, values_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list IndexPutBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto accumulate = packed_args.unpack<bool>();
  auto indices = packed_args.unpack<torch::List<std::optional<Tensor>>>();
  auto values_info = packed_args.unpack<torch::autograd::generated::TypeAndSize>();
  return IndexPutBackward0_apply_functional(variable_list(grads), needs_input_grad, accumulate, indices, values_info);
#endif
}

variable_list IndexPutBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!indices_released_, ERR_BACKWARD_TWICE);
  auto indices = unpack_opt_list(indices_);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto values_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ values_ix }),
  };
  return IndexPutBackward0_apply_functional(std::move(grads), needs_input_grad, accumulate, indices, values_info);
}

void IndexPutBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(accumulate);
    args.collect(indices_, false);
    args.collect(values_info);
}
variable_list IndexPutBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(accumulate);
  saved.before(indices_);
  saved.before(values_info);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::List<std::optional<Tensor>>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::autograd::generated::TypeAndSize>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), IndexPutBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!indices_released_, ERR_BACKWARD_TWICE);
  auto indices = unpack_opt_list(indices_);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto values_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ values_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(accumulate);
  packed_args.pack(indices);
  packed_args.pack(values_info);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(accumulate);
  saved.after(indices_);
  saved.after(values_info);
  return output_result;
#endif
}

static variable_list UnsafeIndexPutBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, bool& accumulate, torch::List<std::optional<Tensor>>& indices, torch::autograd::generated::TypeAndSize& values_info)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto values_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (accumulate ? grad : at::_unsafe_index_put(grad, indices, values_info.zeros(), false)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  if (needs_input_grad[/*values*/1]) {
    auto grad_result = any_grad_defined ? (at::_unsafe_index(grad, indices)) : Tensor();
    copy_range(grad_inputs, values_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list UnsafeIndexPutBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto accumulate = packed_args.unpack<bool>();
  auto indices = packed_args.unpack<torch::List<std::optional<Tensor>>>();
  auto values_info = packed_args.unpack<torch::autograd::generated::TypeAndSize>();
  return UnsafeIndexPutBackward0_apply_functional(variable_list(grads), needs_input_grad, accumulate, indices, values_info);
#endif
}

variable_list UnsafeIndexPutBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!indices_released_, ERR_BACKWARD_TWICE);
  auto indices = unpack_opt_list(indices_);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto values_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ values_ix }),
  };
  return UnsafeIndexPutBackward0_apply_functional(std::move(grads), needs_input_grad, accumulate, indices, values_info);
}

void UnsafeIndexPutBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(accumulate);
    args.collect(indices_, false);
    args.collect(values_info);
}
variable_list UnsafeIndexPutBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(accumulate);
  saved.before(indices_);
  saved.before(values_info);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::List<std::optional<Tensor>>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::autograd::generated::TypeAndSize>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), UnsafeIndexPutBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!indices_released_, ERR_BACKWARD_TWICE);
  auto indices = unpack_opt_list(indices_);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto values_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ values_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(accumulate);
  packed_args.pack(indices);
  packed_args.pack(values_info);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(accumulate);
  saved.after(indices_);
  saved.after(values_info);
  return output_result;
#endif
}

static variable_list IndexPutImplBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, bool& accumulate, torch::List<std::optional<Tensor>>& indices, torch::autograd::generated::TypeAndSize& values_info)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto values_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (accumulate ? grad : grad.index_put(indices, values_info.zeros(), false)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  if (needs_input_grad[/*values*/1]) {
    auto grad_result = any_grad_defined ? (grad.index(indices)) : Tensor();
    copy_range(grad_inputs, values_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list IndexPutImplBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto accumulate = packed_args.unpack<bool>();
  auto indices = packed_args.unpack<torch::List<std::optional<Tensor>>>();
  auto values_info = packed_args.unpack<torch::autograd::generated::TypeAndSize>();
  return IndexPutImplBackward0_apply_functional(variable_list(grads), needs_input_grad, accumulate, indices, values_info);
#endif
}

variable_list IndexPutImplBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!indices_released_, ERR_BACKWARD_TWICE);
  auto indices = unpack_opt_list(indices_);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto values_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ values_ix }),
  };
  return IndexPutImplBackward0_apply_functional(std::move(grads), needs_input_grad, accumulate, indices, values_info);
}

void IndexPutImplBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(accumulate);
    args.collect(indices_, false);
    args.collect(values_info);
}
variable_list IndexPutImplBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(accumulate);
  saved.before(indices_);
  saved.before(values_info);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::List<std::optional<Tensor>>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::autograd::generated::TypeAndSize>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), IndexPutImplBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!indices_released_, ERR_BACKWARD_TWICE);
  auto indices = unpack_opt_list(indices_);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto values_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ values_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(accumulate);
  packed_args.pack(indices);
  packed_args.pack(values_info);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(accumulate);
  saved.after(indices_);
  saved.after(values_info);
  return output_result;
#endif
}

static variable_list IndexSelectBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim, Tensor& index, std::vector<c10::SymInt>& self_sym_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (index_select_backward_symint(grad, self_sym_sizes, dim, index)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list IndexSelectBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  auto index = packed_args.unpack<Tensor>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return IndexSelectBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, index, self_sym_sizes);
#endif
}

variable_list IndexSelectBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto index = index_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return IndexSelectBackward0_apply_functional(std::move(grads), needs_input_grad, dim, index, self_sym_sizes);
}

void IndexSelectBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(index_, false);
    args.collect(self_sym_sizes);
}
variable_list IndexSelectBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(index_);
  saved.before(self_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), IndexSelectBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto index = index_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(index);
  packed_args.pack(self_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(index_);
  saved.after(self_sym_sizes);
  return output_result;
#endif
}

static variable_list LinalgInvExBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& inverse)
{
  IndexRangeGenerator gen;
  auto A_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*A*/0]) {
    auto grad_result = any_grad_defined ? (-at::matmul(inverse.mH(), at::matmul(grad, inverse.mH()))) : Tensor();
    copy_range(grad_inputs, A_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list LinalgInvExBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto inverse = packed_args.unpack<Tensor>();
  return LinalgInvExBackward0_apply_functional(variable_list(grads), needs_input_grad, inverse);
#endif
}

variable_list LinalgInvExBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto inverse = inverse_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto A_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ A_ix }),
  };
  return LinalgInvExBackward0_apply_functional(std::move(grads), needs_input_grad, inverse);
}

void LinalgInvExBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(inverse_, true);
}
variable_list LinalgInvExBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(inverse_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), LinalgInvExBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto inverse = inverse_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto A_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ A_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(inverse);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(inverse_);
  return output_result;
#endif
}

static variable_list LinalgPinvBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (pinv_backward(grad, result, self)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list LinalgPinvBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  auto result = packed_args.unpack<Tensor>();
  return LinalgPinvBackward0_apply_functional(variable_list(grads), needs_input_grad, self, result);
#endif
}

variable_list LinalgPinvBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return LinalgPinvBackward0_apply_functional(std::move(grads), needs_input_grad, self, result);
}

void LinalgPinvBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
    args.collect(result_, true);
}
variable_list LinalgPinvBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), LinalgPinvBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list KthvalueBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim, bool& keepdim, std::vector<c10::SymInt>& self_sym_sizes, Tensor& indices)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (value_selecting_reduction_backward_symint(grad, dim, indices, self_sym_sizes, keepdim)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list KthvalueBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  auto keepdim = packed_args.unpack<bool>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  auto indices = packed_args.unpack<Tensor>();
  return KthvalueBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, keepdim, self_sym_sizes, indices);
#endif
}

variable_list KthvalueBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto indices = indices_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return KthvalueBackward0_apply_functional(std::move(grads), needs_input_grad, dim, keepdim, self_sym_sizes, indices);
}

void KthvalueBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(keepdim);
    args.collect(self_sym_sizes);
    args.collect(indices_, true);
}
variable_list KthvalueBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(keepdim);
  saved.before(self_sym_sizes);
  saved.before(indices_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), KthvalueBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto indices = indices_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(keepdim);
  packed_args.pack(self_sym_sizes);
  packed_args.pack(indices);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(keepdim);
  saved.after(self_sym_sizes);
  saved.after(indices_);
  return output_result;
#endif
}

static variable_list LeBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, torch::autograd::generated::TypeAndSize& self_info)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (self_info.zeros()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list LeBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_info = packed_args.unpack<torch::autograd::generated::TypeAndSize>();
  return LeBackward0_apply_functional(variable_list(grads), needs_input_grad, self_info);
#endif
}

variable_list LeBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return LeBackward0_apply_functional(std::move(grads), needs_input_grad, self_info);
}

void LeBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_info);
}
variable_list LeBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_info);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::autograd::generated::TypeAndSize>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), LeBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_info);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_info);
  return output_result;
#endif
}

static variable_list LeBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, torch::autograd::generated::TypeAndSize& other_info, torch::autograd::generated::TypeAndSize& self_info)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*other*/1]) {
    auto grad_result = any_grad_defined ? (other_info.zeros()) : Tensor();
    copy_range(grad_inputs, other_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (self_info.zeros()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list LeBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto other_info = packed_args.unpack<torch::autograd::generated::TypeAndSize>();
  auto self_info = packed_args.unpack<torch::autograd::generated::TypeAndSize>();
  return LeBackward1_apply_functional(variable_list(grads), needs_input_grad, other_info, self_info);
#endif
}

variable_list LeBackward1::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  return LeBackward1_apply_functional(std::move(grads), needs_input_grad, other_info, self_info);
}

void LeBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(other_info);
    args.collect(self_info);
}
variable_list LeBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(other_info);
  saved.before(self_info);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::autograd::generated::TypeAndSize>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::autograd::generated::TypeAndSize>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), LeBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(other_info);
  packed_args.pack(self_info);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(other_info);
  saved.after(self_info);
  return output_result;
#endif
}

static variable_list LerpBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, at::Scalar& weight)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto end_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*end*/1]) {
    auto grad_result = any_grad_defined ? (grad * weight.conj()) : Tensor();
    copy_range(grad_inputs, end_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (weight.isComplex() ? grad * (1 - weight.conj().toComplexDouble()) : grad * (1 - weight.toDouble())) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list LerpBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto weight = packed_args.unpack<at::Scalar>();
  return LerpBackward0_apply_functional(variable_list(grads), needs_input_grad, weight);
#endif
}

variable_list LerpBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto end_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ end_ix }),
  };
  return LerpBackward0_apply_functional(std::move(grads), needs_input_grad, weight);
}

void LerpBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(weight);
}
variable_list LerpBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(weight);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), LerpBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto end_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ end_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(weight);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(weight);
  return output_result;
#endif
}

static variable_list LerpBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, Tensor& end, Tensor& self, Tensor& weight)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto end_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*end*/1]) {
    auto grad_result = any_grad_defined ? (grad * weight.conj()) : Tensor();
    copy_range(grad_inputs, end_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad * (1 - weight).conj()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  if (needs_input_grad[/*weight*/2]) {
    auto grad_result = any_grad_defined ? (grad * (end - self).conj()) : Tensor();
    copy_range(grad_inputs, weight_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list LerpBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto end = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<Tensor>();
  auto weight = packed_args.unpack<Tensor>();
  return LerpBackward1_apply_functional(variable_list(grads), needs_input_grad, end, self, weight);
#endif
}

variable_list LerpBackward1::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto end = end_.unpack();
  auto self = self_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto end_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ end_ix }),
    task_should_compute_output({ weight_ix }),
  };
  return LerpBackward1_apply_functional(std::move(grads), needs_input_grad, end, self, weight);
}

void LerpBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(end_, false);
    args.collect(self_, false);
    args.collect(weight_, false);
}
variable_list LerpBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(end_);
  saved.before(self_);
  saved.before(weight_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), LerpBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto end = end_.unpack();
  auto self = self_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto end_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ end_ix }),
    task_should_compute_output({ weight_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(end);
  packed_args.pack(self);
  packed_args.pack(weight);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(end_);
  saved.after(self_);
  saved.after(weight_);
  return output_result;
#endif
}

static variable_list LgammaBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad * digamma(self)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list LgammaBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  return LgammaBackward0_apply_functional(variable_list(grads), needs_input_grad, self);
#endif
}

variable_list LgammaBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return LgammaBackward0_apply_functional(std::move(grads), needs_input_grad, self);
}

void LgammaBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list LgammaBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), LgammaBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list DigammaBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad * polygamma(1, self)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list DigammaBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  return DigammaBackward0_apply_functional(variable_list(grads), needs_input_grad, self);
#endif
}

variable_list DigammaBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return DigammaBackward0_apply_functional(std::move(grads), needs_input_grad, self);
}

void DigammaBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list DigammaBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), DigammaBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list PolygammaBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& n, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad * polygamma(n + 1, self)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list PolygammaBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto n = packed_args.unpack<int64_t>();
  auto self = packed_args.unpack<Tensor>();
  return PolygammaBackward0_apply_functional(variable_list(grads), needs_input_grad, n, self);
#endif
}

variable_list PolygammaBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return PolygammaBackward0_apply_functional(std::move(grads), needs_input_grad, n, self);
}

void PolygammaBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(n);
    args.collect(self_, false);
}
variable_list PolygammaBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(n);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), PolygammaBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(n);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(n);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list PolygammaBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& n, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad * polygamma(n + 1, self)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list PolygammaBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto n = packed_args.unpack<int64_t>();
  auto self = packed_args.unpack<Tensor>();
  return PolygammaBackward1_apply_functional(variable_list(grads), needs_input_grad, n, self);
#endif
}

variable_list PolygammaBackward1::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return PolygammaBackward1_apply_functional(std::move(grads), needs_input_grad, n, self);
}

void PolygammaBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(n);
    args.collect(self_, false);
}
variable_list PolygammaBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(n);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), PolygammaBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(n);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(n);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list LogBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.div(self.conj())) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list LogBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  return LogBackward0_apply_functional(variable_list(grads), needs_input_grad, self);
#endif
}

variable_list LogBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return LogBackward0_apply_functional(std::move(grads), needs_input_grad, self);
}

void LogBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list LogBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), LogBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list Log10Backward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad / (self.conj() * 2.3025850929940456)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list Log10Backward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  return Log10Backward0_apply_functional(variable_list(grads), needs_input_grad, self);
#endif
}

variable_list Log10Backward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return Log10Backward0_apply_functional(std::move(grads), needs_input_grad, self);
}

void Log10Backward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list Log10Backward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), Log10Backward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list Log1PBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (log1p_backward(grad, self)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list Log1PBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  return Log1PBackward0_apply_functional(variable_list(grads), needs_input_grad, self);
#endif
}

variable_list Log1PBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return Log1PBackward0_apply_functional(std::move(grads), needs_input_grad, self);
}

void Log1PBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list Log1PBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), Log1PBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list Log2Backward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad / (self.conj() * 0.6931471805599453)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list Log2Backward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  return Log2Backward0_apply_functional(variable_list(grads), needs_input_grad, self);
#endif
}

variable_list Log2Backward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return Log2Backward0_apply_functional(std::move(grads), needs_input_grad, self);
}

void Log2Backward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list Log2Backward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), Log2Backward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list LogaddexpBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& other, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*other*/1]) {
    auto grad_result = any_grad_defined ? (grad / (1 + exp(self - other)).conj()) : Tensor();
    copy_range(grad_inputs, other_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad / (1 + exp(other - self)).conj()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list LogaddexpBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto other = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<Tensor>();
  return LogaddexpBackward0_apply_functional(variable_list(grads), needs_input_grad, other, self);
#endif
}

variable_list LogaddexpBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto other = other_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  return LogaddexpBackward0_apply_functional(std::move(grads), needs_input_grad, other, self);
}

void LogaddexpBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(other_, false);
    args.collect(self_, false);
}
variable_list LogaddexpBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(other_);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), LogaddexpBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto other = other_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(other);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(other_);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list Logaddexp2Backward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& other, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*other*/1]) {
    auto grad_result = any_grad_defined ? (grad / (1 + pow(2, self - other))) : Tensor();
    copy_range(grad_inputs, other_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad / (1 + pow(2, other - self))) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list Logaddexp2Backward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto other = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<Tensor>();
  return Logaddexp2Backward0_apply_functional(variable_list(grads), needs_input_grad, other, self);
#endif
}

variable_list Logaddexp2Backward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto other = other_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  return Logaddexp2Backward0_apply_functional(std::move(grads), needs_input_grad, other, self);
}

void Logaddexp2Backward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(other_, false);
    args.collect(self_, false);
}
variable_list Logaddexp2Backward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(other_);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), Logaddexp2Backward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto other = other_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(other);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(other_);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list XlogyBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& other, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*other*/1]) {
    auto grad_result = any_grad_defined ? (grad * self / other) : Tensor();
    copy_range(grad_inputs, other_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (at::xlogy(grad, other).masked_fill((self == 0.) & (other <= 0.), 0.)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list XlogyBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto other = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<Tensor>();
  return XlogyBackward0_apply_functional(variable_list(grads), needs_input_grad, other, self);
#endif
}

variable_list XlogyBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto other = other_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  return XlogyBackward0_apply_functional(std::move(grads), needs_input_grad, other, self);
}

void XlogyBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(other_, false);
    args.collect(self_, false);
}
variable_list XlogyBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(other_);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), XlogyBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto other = other_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(other);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(other_);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list XlogyBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& other, at::Scalar& self)
{
  IndexRangeGenerator gen;
  auto other_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*other*/0]) {
    auto grad_result = any_grad_defined ? (grad * self / other) : Tensor();
    copy_range(grad_inputs, other_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list XlogyBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto other = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<at::Scalar>();
  return XlogyBackward1_apply_functional(variable_list(grads), needs_input_grad, other, self);
#endif
}

variable_list XlogyBackward1::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto other = other_.unpack();
  IndexRangeGenerator gen;
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ other_ix }),
  };
  return XlogyBackward1_apply_functional(std::move(grads), needs_input_grad, other, self);
}

void XlogyBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(other_, false);
    args.collect(self);
}
variable_list XlogyBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(other_);
  saved.before(self);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), XlogyBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto other = other_.unpack();
  IndexRangeGenerator gen;
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ other_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(other);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(other_);
  saved.after(self);
  return output_result;
#endif
}

static variable_list XlogyBackward2_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, at::Scalar& other, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (other.toDouble() > 0. ? at::xlogy(grad,  other) : at::xlogy(grad,  other).masked_fill(self == 0., 0.)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list XlogyBackward2_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto other = packed_args.unpack<at::Scalar>();
  auto self = packed_args.unpack<Tensor>();
  return XlogyBackward2_apply_functional(variable_list(grads), needs_input_grad, other, self);
#endif
}

variable_list XlogyBackward2::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return XlogyBackward2_apply_functional(std::move(grads), needs_input_grad, other, self);
}

void XlogyBackward2::compiled_args(CompiledNodeArgs& args) const {
    args.collect(other);
    args.collect(self_, false);
}
variable_list XlogyBackward2::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(other);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), XlogyBackward2_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(other);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(other);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list SpecialXlog1PyBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& other, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*other*/1]) {
    auto grad_result = any_grad_defined ? (grad * self / (other + 1)) : Tensor();
    copy_range(grad_inputs, other_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (at::special_xlog1py(grad,  other).masked_fill((self == 0.) & (other <= -1.), 0.)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SpecialXlog1PyBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto other = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<Tensor>();
  return SpecialXlog1PyBackward0_apply_functional(variable_list(grads), needs_input_grad, other, self);
#endif
}

variable_list SpecialXlog1PyBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto other = other_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  return SpecialXlog1PyBackward0_apply_functional(std::move(grads), needs_input_grad, other, self);
}

void SpecialXlog1PyBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(other_, false);
    args.collect(self_, false);
}
variable_list SpecialXlog1PyBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(other_);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SpecialXlog1PyBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto other = other_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(other);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(other_);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list SpecialXlog1PyBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& other, at::Scalar& self)
{
  IndexRangeGenerator gen;
  auto other_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*other*/0]) {
    auto grad_result = any_grad_defined ? (grad * self / (other + 1)) : Tensor();
    copy_range(grad_inputs, other_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SpecialXlog1PyBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto other = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<at::Scalar>();
  return SpecialXlog1PyBackward1_apply_functional(variable_list(grads), needs_input_grad, other, self);
#endif
}

variable_list SpecialXlog1PyBackward1::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto other = other_.unpack();
  IndexRangeGenerator gen;
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ other_ix }),
  };
  return SpecialXlog1PyBackward1_apply_functional(std::move(grads), needs_input_grad, other, self);
}

void SpecialXlog1PyBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(other_, false);
    args.collect(self);
}
variable_list SpecialXlog1PyBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(other_);
  saved.before(self);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SpecialXlog1PyBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto other = other_.unpack();
  IndexRangeGenerator gen;
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ other_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(other);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(other_);
  saved.after(self);
  return output_result;
#endif
}

static variable_list SpecialXlog1PyBackward2_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, at::Scalar& other, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (other.toDouble() > -1. ? at::special_xlog1py(grad,  other) : at::special_xlog1py(grad,  other).masked_fill(self == 0., 0.)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SpecialXlog1PyBackward2_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto other = packed_args.unpack<at::Scalar>();
  auto self = packed_args.unpack<Tensor>();
  return SpecialXlog1PyBackward2_apply_functional(variable_list(grads), needs_input_grad, other, self);
#endif
}

variable_list SpecialXlog1PyBackward2::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SpecialXlog1PyBackward2_apply_functional(std::move(grads), needs_input_grad, other, self);
}

void SpecialXlog1PyBackward2::compiled_args(CompiledNodeArgs& args) const {
    args.collect(other);
    args.collect(self_, false);
}
variable_list SpecialXlog1PyBackward2::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(other);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SpecialXlog1PyBackward2_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(other);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(other);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list SpecialZetaBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& other, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*other*/1]) {
    auto grad_result = any_grad_defined ? (grad * -self * special_zeta(self + 1., other)) : Tensor();
    copy_range(grad_inputs, other_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = not_implemented("zeta");
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SpecialZetaBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto other = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<Tensor>();
  return SpecialZetaBackward0_apply_functional(variable_list(grads), needs_input_grad, other, self);
#endif
}

variable_list SpecialZetaBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto other = other_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  return SpecialZetaBackward0_apply_functional(std::move(grads), needs_input_grad, other, self);
}

void SpecialZetaBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(other_, false);
    args.collect(self_, false);
}
variable_list SpecialZetaBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(other_);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SpecialZetaBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto other = other_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(other);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(other_);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list SpecialZetaBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& other, at::Scalar& self)
{
  IndexRangeGenerator gen;
  auto other_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*other*/0]) {
    auto grad_result = any_grad_defined ? (grad * -self * special_zeta(self.toDouble() + 1., other)) : Tensor();
    copy_range(grad_inputs, other_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SpecialZetaBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto other = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<at::Scalar>();
  return SpecialZetaBackward1_apply_functional(variable_list(grads), needs_input_grad, other, self);
#endif
}

variable_list SpecialZetaBackward1::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto other = other_.unpack();
  IndexRangeGenerator gen;
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ other_ix }),
  };
  return SpecialZetaBackward1_apply_functional(std::move(grads), needs_input_grad, other, self);
}

void SpecialZetaBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(other_, false);
    args.collect(self);
}
variable_list SpecialZetaBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(other_);
  saved.before(self);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SpecialZetaBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto other = other_.unpack();
  IndexRangeGenerator gen;
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ other_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(other);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(other_);
  saved.after(self);
  return output_result;
#endif
}

static variable_list SpecialZetaBackward2_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = not_implemented("zeta");
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SpecialZetaBackward2_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return SpecialZetaBackward2_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list SpecialZetaBackward2::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SpecialZetaBackward2_apply_functional(std::move(grads), needs_input_grad);
}

void SpecialZetaBackward2::compiled_args(CompiledNodeArgs& args) const {

}
variable_list SpecialZetaBackward2::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SpecialZetaBackward2_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list LogNormalBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (zeros_like(grad)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list LogNormalBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return LogNormalBackward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list LogNormalBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return LogNormalBackward0_apply_functional(std::move(grads), needs_input_grad);
}

void LogNormalBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list LogNormalBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), LogNormalBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list LogsumexpBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<int64_t>& dim, bool& keepdim, Tensor& self, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (logsumexp_backward(grad, self, result, dim, keepdim)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list LogsumexpBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<std::vector<int64_t>>();
  auto keepdim = packed_args.unpack<bool>();
  auto self = packed_args.unpack<Tensor>();
  auto result = packed_args.unpack<Tensor>();
  return LogsumexpBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, keepdim, self, result);
#endif
}

variable_list LogsumexpBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return LogsumexpBackward0_apply_functional(std::move(grads), needs_input_grad, dim, keepdim, self, result);
}

void LogsumexpBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(keepdim);
    args.collect(self_, false);
    args.collect(result_, true);
}
variable_list LogsumexpBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(keepdim);
  saved.before(self_);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), LogsumexpBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(keepdim);
  packed_args.pack(self);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(keepdim);
  saved.after(self_);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list LinalgLstsqBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& b, Tensor& self, Tensor& solution)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto b_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[0] || needs_input_grad[1]) {
      auto grad_input_mask = std::array<bool, 2>{
        needs_input_grad[0],
        needs_input_grad[1],
      };
    auto grad_result = linalg_lstsq_backward(grads[0], grads[1], self, b, solution, grad_input_mask);
      if (needs_input_grad[/*self*/0]) {
        copy_range(grad_inputs, self_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*b*/1]) {
        copy_range(grad_inputs, b_ix, std::get<1>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list LinalgLstsqBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto b = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<Tensor>();
  auto solution = packed_args.unpack<Tensor>();
  return LinalgLstsqBackward0_apply_functional(variable_list(grads), needs_input_grad, b, self, solution);
#endif
}

variable_list LinalgLstsqBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto b = b_.unpack();
  auto self = self_.unpack();
  auto solution = solution_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto b_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ b_ix }),
  };
  return LinalgLstsqBackward0_apply_functional(std::move(grads), needs_input_grad, b, self, solution);
}

void LinalgLstsqBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(b_, false);
    args.collect(self_, false);
    args.collect(solution_, true);
}
variable_list LinalgLstsqBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(b_);
  saved.before(self_);
  saved.before(solution_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), LinalgLstsqBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto b = b_.unpack();
  auto self = self_.unpack();
  auto solution = solution_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto b_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ b_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(b);
  packed_args.pack(self);
  packed_args.pack(solution);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(b_);
  saved.after(self_);
  saved.after(solution_);
  return output_result;
#endif
}

static variable_list LtBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, torch::autograd::generated::TypeAndSize& self_info)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (self_info.zeros()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list LtBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_info = packed_args.unpack<torch::autograd::generated::TypeAndSize>();
  return LtBackward0_apply_functional(variable_list(grads), needs_input_grad, self_info);
#endif
}

variable_list LtBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return LtBackward0_apply_functional(std::move(grads), needs_input_grad, self_info);
}

void LtBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_info);
}
variable_list LtBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_info);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::autograd::generated::TypeAndSize>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), LtBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_info);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_info);
  return output_result;
#endif
}

static variable_list LtBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, torch::autograd::generated::TypeAndSize& other_info, torch::autograd::generated::TypeAndSize& self_info)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*other*/1]) {
    auto grad_result = any_grad_defined ? (other_info.zeros()) : Tensor();
    copy_range(grad_inputs, other_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (self_info.zeros()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list LtBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto other_info = packed_args.unpack<torch::autograd::generated::TypeAndSize>();
  auto self_info = packed_args.unpack<torch::autograd::generated::TypeAndSize>();
  return LtBackward1_apply_functional(variable_list(grads), needs_input_grad, other_info, self_info);
#endif
}

variable_list LtBackward1::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  return LtBackward1_apply_functional(std::move(grads), needs_input_grad, other_info, self_info);
}

void LtBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(other_info);
    args.collect(self_info);
}
variable_list LtBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(other_info);
  saved.before(self_info);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::autograd::generated::TypeAndSize>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::autograd::generated::TypeAndSize>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), LtBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(other_info);
  packed_args.pack(self_info);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(other_info);
  saved.after(self_info);
  return output_result;
#endif
}

static variable_list LinalgLuFactorExBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, bool& pivot, Tensor& LU, Tensor& pivots)
{
  IndexRangeGenerator gen;
  auto A_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*A*/0]) {
    auto grad_result = any_grad_defined ? (lu_factor_ex_backward(grad, LU, pivots, pivot)) : Tensor();
    copy_range(grad_inputs, A_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list LinalgLuFactorExBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto pivot = packed_args.unpack<bool>();
  auto LU = packed_args.unpack<Tensor>();
  auto pivots = packed_args.unpack<Tensor>();
  return LinalgLuFactorExBackward0_apply_functional(variable_list(grads), needs_input_grad, pivot, LU, pivots);
#endif
}

variable_list LinalgLuFactorExBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto LU = LU_.unpack(shared_from_this());
  auto pivots = pivots_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto A_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ A_ix }),
  };
  return LinalgLuFactorExBackward0_apply_functional(std::move(grads), needs_input_grad, pivot, LU, pivots);
}

void LinalgLuFactorExBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(pivot);
    args.collect(LU_, true);
    args.collect(pivots_, true);
}
variable_list LinalgLuFactorExBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(pivot);
  saved.before(LU_);
  saved.before(pivots_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), LinalgLuFactorExBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto LU = LU_.unpack(shared_from_this());
  auto pivots = pivots_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto A_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ A_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(pivot);
  packed_args.pack(LU);
  packed_args.pack(pivots);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(pivot);
  saved.after(LU_);
  saved.after(pivots_);
  return output_result;
#endif
}

static variable_list LinalgLuFactorBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, bool& pivot, Tensor& LU, Tensor& pivots)
{
  IndexRangeGenerator gen;
  auto A_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*A*/0]) {
    auto grad_result = any_grad_defined ? (lu_factor_ex_backward(grad, LU, pivots, pivot)) : Tensor();
    copy_range(grad_inputs, A_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list LinalgLuFactorBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto pivot = packed_args.unpack<bool>();
  auto LU = packed_args.unpack<Tensor>();
  auto pivots = packed_args.unpack<Tensor>();
  return LinalgLuFactorBackward0_apply_functional(variable_list(grads), needs_input_grad, pivot, LU, pivots);
#endif
}

variable_list LinalgLuFactorBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto LU = LU_.unpack(shared_from_this());
  auto pivots = pivots_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto A_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ A_ix }),
  };
  return LinalgLuFactorBackward0_apply_functional(std::move(grads), needs_input_grad, pivot, LU, pivots);
}

void LinalgLuFactorBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(pivot);
    args.collect(LU_, true);
    args.collect(pivots_, true);
}
variable_list LinalgLuFactorBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(pivot);
  saved.before(LU_);
  saved.before(pivots_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), LinalgLuFactorBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto LU = LU_.unpack(shared_from_this());
  auto pivots = pivots_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto A_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ A_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(pivot);
  packed_args.pack(LU);
  packed_args.pack(pivots);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(pivot);
  saved.after(LU_);
  saved.after(pivots_);
  return output_result;
#endif
}

static variable_list LinalgLuBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, bool& pivot, Tensor& L, Tensor& P, Tensor& U)
{
  IndexRangeGenerator gen;
  auto A_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad_L = grads[0];
  const auto& grad_U = grads[1];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*A*/0]) {
    auto grad_result = any_grad_defined ? (linalg_lu_backward(grad_L, grad_U, P, L, U, pivot)) : Tensor();
    copy_range(grad_inputs, A_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list LinalgLuBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto pivot = packed_args.unpack<bool>();
  auto L = packed_args.unpack<Tensor>();
  auto P = packed_args.unpack<Tensor>();
  auto U = packed_args.unpack<Tensor>();
  return LinalgLuBackward0_apply_functional(variable_list(grads), needs_input_grad, pivot, L, P, U);
#endif
}

variable_list LinalgLuBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto L = L_.unpack(shared_from_this());
  auto P = P_.unpack(shared_from_this());
  auto U = U_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto A_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ A_ix }),
  };
  return LinalgLuBackward0_apply_functional(std::move(grads), needs_input_grad, pivot, L, P, U);
}

void LinalgLuBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(pivot);
    args.collect(L_, true);
    args.collect(P_, true);
    args.collect(U_, true);
}
variable_list LinalgLuBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(pivot);
  saved.before(L_);
  saved.before(P_);
  saved.before(U_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), LinalgLuBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto L = L_.unpack(shared_from_this());
  auto P = P_.unpack(shared_from_this());
  auto U = U_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto A_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ A_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(pivot);
  packed_args.pack(L);
  packed_args.pack(P);
  packed_args.pack(U);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(pivot);
  saved.after(L_);
  saved.after(P_);
  saved.after(U_);
  return output_result;
#endif
}

static variable_list LinalgLuSolveBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& LU, bool& adjoint, bool& left, Tensor& pivots, Tensor& result)
{
  IndexRangeGenerator gen;
  auto LU_ix = gen.range(1);
  auto B_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*B*/1]) {
    auto grad_result = any_grad_defined ? (at::linalg_lu_solve(LU, pivots, grad, left, !adjoint)) : Tensor();
    copy_range(grad_inputs, B_ix, grad_result);
  }
  if (needs_input_grad[/*LU*/0]) {
    auto grad_result = any_grad_defined ? (linalg_lu_solve_LU(grad, LU, pivots, result, left, adjoint)) : Tensor();
    copy_range(grad_inputs, LU_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list LinalgLuSolveBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto LU = packed_args.unpack<Tensor>();
  auto adjoint = packed_args.unpack<bool>();
  auto left = packed_args.unpack<bool>();
  auto pivots = packed_args.unpack<Tensor>();
  auto result = packed_args.unpack<Tensor>();
  return LinalgLuSolveBackward0_apply_functional(variable_list(grads), needs_input_grad, LU, adjoint, left, pivots, result);
#endif
}

variable_list LinalgLuSolveBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto LU = LU_.unpack();
  auto pivots = pivots_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto LU_ix = gen.range(1);
  auto B_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ LU_ix }),
    task_should_compute_output({ B_ix }),
  };
  return LinalgLuSolveBackward0_apply_functional(std::move(grads), needs_input_grad, LU, adjoint, left, pivots, result);
}

void LinalgLuSolveBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(LU_, false);
    args.collect(adjoint);
    args.collect(left);
    args.collect(pivots_, false);
    args.collect(result_, true);
}
variable_list LinalgLuSolveBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(LU_);
  saved.before(adjoint);
  saved.before(left);
  saved.before(pivots_);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), LinalgLuSolveBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto LU = LU_.unpack();
  auto pivots = pivots_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto LU_ix = gen.range(1);
  auto B_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ LU_ix }),
    task_should_compute_output({ B_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(LU);
  packed_args.pack(adjoint);
  packed_args.pack(left);
  packed_args.pack(pivots);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(LU_);
  saved.after(adjoint);
  saved.after(left);
  saved.after(pivots_);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list LuUnpackBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, c10::SymInt& LU_data_sym_argsize_minus_1, c10::SymInt& LU_data_sym_argsize_minus_2)
{
  IndexRangeGenerator gen;
  auto LU_data_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad_L = grads[0];
  const auto& grad_U = grads[1];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*LU_data*/0]) {
    auto grad_result = any_grad_defined ? (lu_unpack_backward(grad_L, grad_U, LU_data_sym_argsize_minus_2, LU_data_sym_argsize_minus_1)) : Tensor();
    copy_range(grad_inputs, LU_data_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list LuUnpackBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto LU_data_sym_argsize_minus_1 = packed_args.unpack<c10::SymInt>();
  auto LU_data_sym_argsize_minus_2 = packed_args.unpack<c10::SymInt>();
  return LuUnpackBackward0_apply_functional(variable_list(grads), needs_input_grad, LU_data_sym_argsize_minus_1, LU_data_sym_argsize_minus_2);
#endif
}

variable_list LuUnpackBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto LU_data_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ LU_data_ix }),
  };
  return LuUnpackBackward0_apply_functional(std::move(grads), needs_input_grad, LU_data_sym_argsize_minus_1, LU_data_sym_argsize_minus_2);
}

void LuUnpackBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(LU_data_sym_argsize_minus_1);
    args.collect(LU_data_sym_argsize_minus_2);
}
variable_list LuUnpackBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(LU_data_sym_argsize_minus_1);
  saved.before(LU_data_sym_argsize_minus_2);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), LuUnpackBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto LU_data_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ LU_data_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(LU_data_sym_argsize_minus_1);
  packed_args.pack(LU_data_sym_argsize_minus_2);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(LU_data_sym_argsize_minus_1);
  saved.after(LU_data_sym_argsize_minus_2);
  return output_result;
#endif
}

static variable_list MaskedFillBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& mask)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.masked_fill(mask, 0)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list MaskedFillBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto mask = packed_args.unpack<Tensor>();
  return MaskedFillBackward0_apply_functional(variable_list(grads), needs_input_grad, mask);
#endif
}

variable_list MaskedFillBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto mask = mask_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return MaskedFillBackward0_apply_functional(std::move(grads), needs_input_grad, mask);
}

void MaskedFillBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(mask_, false);
}
variable_list MaskedFillBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(mask_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MaskedFillBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto mask = mask_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(mask);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(mask_);
  return output_result;
#endif
}

static variable_list MaskedFillBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& mask)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto value_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.masked_fill(mask, 0)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  if (needs_input_grad[/*value*/1]) {
    auto grad_result = any_grad_defined ? (masked_fill_backward(grad, mask)) : Tensor();
    copy_range(grad_inputs, value_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list MaskedFillBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto mask = packed_args.unpack<Tensor>();
  return MaskedFillBackward1_apply_functional(variable_list(grads), needs_input_grad, mask);
#endif
}

variable_list MaskedFillBackward1::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto mask = mask_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto value_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ value_ix }),
  };
  return MaskedFillBackward1_apply_functional(std::move(grads), needs_input_grad, mask);
}

void MaskedFillBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(mask_, false);
}
variable_list MaskedFillBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(mask_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MaskedFillBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto mask = mask_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto value_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ value_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(mask);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(mask_);
  return output_result;
#endif
}

static variable_list MaskedScatterBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& mask, std::vector<c10::SymInt>& source_sym_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto source_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.masked_fill(mask, 0)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  if (needs_input_grad[/*source*/1]) {
    auto grad_result = any_grad_defined ? (masked_scatter_backward_symint(grad, mask, source_sym_sizes)) : Tensor();
    copy_range(grad_inputs, source_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list MaskedScatterBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto mask = packed_args.unpack<Tensor>();
  auto source_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return MaskedScatterBackward0_apply_functional(variable_list(grads), needs_input_grad, mask, source_sym_sizes);
#endif
}

variable_list MaskedScatterBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto mask = mask_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto source_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ source_ix }),
  };
  return MaskedScatterBackward0_apply_functional(std::move(grads), needs_input_grad, mask, source_sym_sizes);
}

void MaskedScatterBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(mask_, false);
    args.collect(source_sym_sizes);
}
variable_list MaskedScatterBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(mask_);
  saved.before(source_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MaskedScatterBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto mask = mask_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto source_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ source_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(mask);
  packed_args.pack(source_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(mask_);
  saved.after(source_sym_sizes);
  return output_result;
#endif
}

static variable_list MaskedScatterBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, torch::autograd::generated::TypeAndSize& grad_output_info, Tensor& mask)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (grad_output_info.zeros().masked_scatter(mask, grad)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list MaskedScatterBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto grad_output_info = packed_args.unpack<torch::autograd::generated::TypeAndSize>();
  auto mask = packed_args.unpack<Tensor>();
  return MaskedScatterBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, grad_output_info, mask);
#endif
}

variable_list MaskedScatterBackwardBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto mask = mask_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ grad_output_ix }),
  };
  return MaskedScatterBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, grad_output_info, mask);
}

void MaskedScatterBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(grad_output_info);
    args.collect(mask_, false);
}
variable_list MaskedScatterBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(grad_output_info);
  saved.before(mask_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::autograd::generated::TypeAndSize>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MaskedScatterBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto mask = mask_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ grad_output_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(grad_output_info);
  packed_args.pack(mask);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(grad_output_info);
  saved.after(mask_);
  return output_result;
#endif
}

static variable_list MaskedSelectBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& mask, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (masked_select_backward(grad, self, mask)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list MaskedSelectBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto mask = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<Tensor>();
  return MaskedSelectBackward0_apply_functional(variable_list(grads), needs_input_grad, mask, self);
#endif
}

variable_list MaskedSelectBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto mask = mask_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return MaskedSelectBackward0_apply_functional(std::move(grads), needs_input_grad, mask, self);
}

void MaskedSelectBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(mask_, false);
    args.collect(self_, false);
}
variable_list MaskedSelectBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(mask_);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MaskedSelectBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto mask = mask_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(mask);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(mask_);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list LinalgMatrixExpBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (linalg_matrix_exp_differential(self, grad, /*adjoint*/ true)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list LinalgMatrixExpBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  return LinalgMatrixExpBackward0_apply_functional(variable_list(grads), needs_input_grad, self);
#endif
}

variable_list LinalgMatrixExpBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return LinalgMatrixExpBackward0_apply_functional(std::move(grads), needs_input_grad, self);
}

void LinalgMatrixExpBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list LinalgMatrixExpBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), LinalgMatrixExpBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list MaxBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim, bool& keepdim, std::vector<c10::SymInt>& self_sym_sizes, Tensor& indices)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (value_selecting_reduction_backward_symint(grad, dim, indices, self_sym_sizes, keepdim)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list MaxBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  auto keepdim = packed_args.unpack<bool>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  auto indices = packed_args.unpack<Tensor>();
  return MaxBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, keepdim, self_sym_sizes, indices);
#endif
}

variable_list MaxBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto indices = indices_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return MaxBackward0_apply_functional(std::move(grads), needs_input_grad, dim, keepdim, self_sym_sizes, indices);
}

void MaxBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(keepdim);
    args.collect(self_sym_sizes);
    args.collect(indices_, true);
}
variable_list MaxBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(keepdim);
  saved.before(self_sym_sizes);
  saved.before(indices_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MaxBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto indices = indices_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(keepdim);
  packed_args.pack(self_sym_sizes);
  packed_args.pack(indices);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(keepdim);
  saved.after(self_sym_sizes);
  saved.after(indices_);
  return output_result;
#endif
}

static variable_list MaxBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (evenly_distribute_backward(grad, self, result)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list MaxBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  auto result = packed_args.unpack<Tensor>();
  return MaxBackward1_apply_functional(variable_list(grads), needs_input_grad, self, result);
#endif
}

variable_list MaxBackward1::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return MaxBackward1_apply_functional(std::move(grads), needs_input_grad, self, result);
}

void MaxBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
    args.collect(result_, true);
}
variable_list MaxBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MaxBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list MaximumBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& other, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*other*/1]) {
    auto grad_result = any_grad_defined ? (at::where(self == other, grad / 2, grad).masked_fill_(self > other, 0)) : Tensor();
    copy_range(grad_inputs, other_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (at::where(self == other, grad / 2, grad).masked_fill_(self < other, 0)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list MaximumBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto other = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<Tensor>();
  return MaximumBackward0_apply_functional(variable_list(grads), needs_input_grad, other, self);
#endif
}

variable_list MaximumBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto other = other_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  return MaximumBackward0_apply_functional(std::move(grads), needs_input_grad, other, self);
}

void MaximumBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(other_, false);
    args.collect(self_, false);
}
variable_list MaximumBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(other_);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MaximumBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto other = other_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(other);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(other_);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list FmaxBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& other, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*other*/1]) {
    auto grad_result = any_grad_defined ? (grad.masked_fill((self >= other).logical_or_(other.isnan()), 0)) : Tensor();
    copy_range(grad_inputs, other_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.masked_fill((self >= other).logical_or_(other.isnan()).logical_not_(), 0)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list FmaxBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto other = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<Tensor>();
  return FmaxBackward0_apply_functional(variable_list(grads), needs_input_grad, other, self);
#endif
}

variable_list FmaxBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto other = other_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  return FmaxBackward0_apply_functional(std::move(grads), needs_input_grad, other, self);
}

void FmaxBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(other_, false);
    args.collect(self_, false);
}
variable_list FmaxBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(other_);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), FmaxBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto other = other_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(other);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(other_);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list MeanBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, c10::SymInt& self_sym_numel, std::vector<c10::SymInt>& self_sym_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.expand_symint(self_sym_sizes) / self_sym_numel) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list MeanBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_sym_numel = packed_args.unpack<c10::SymInt>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return MeanBackward0_apply_functional(variable_list(grads), needs_input_grad, self_sym_numel, self_sym_sizes);
#endif
}

variable_list MeanBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return MeanBackward0_apply_functional(std::move(grads), needs_input_grad, self_sym_numel, self_sym_sizes);
}

void MeanBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_sym_numel);
    args.collect(self_sym_sizes);
}
variable_list MeanBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_sym_numel);
  saved.before(self_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MeanBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_sym_numel);
  packed_args.pack(self_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_sym_numel);
  saved.after(self_sym_sizes);
  return output_result;
#endif
}

static variable_list MeanBackwardAutogradNestedTensor0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self, c10::SymInt& self_sym_numel)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? ((ones_like(self) * grad) / self_sym_numel) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list MeanBackwardAutogradNestedTensor0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  auto self_sym_numel = packed_args.unpack<c10::SymInt>();
  return MeanBackwardAutogradNestedTensor0_apply_functional(variable_list(grads), needs_input_grad, self, self_sym_numel);
#endif
}

variable_list MeanBackwardAutogradNestedTensor0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return MeanBackwardAutogradNestedTensor0_apply_functional(std::move(grads), needs_input_grad, self, self_sym_numel);
}

void MeanBackwardAutogradNestedTensor0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
    args.collect(self_sym_numel);
}
variable_list MeanBackwardAutogradNestedTensor0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);
  saved.before(self_sym_numel);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MeanBackwardAutogradNestedTensor0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);
  packed_args.pack(self_sym_numel);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  saved.after(self_sym_numel);
  return output_result;
#endif
}

static variable_list MeanBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, c10::OptionalArray<int64_t>& dim, bool& keepdim, c10::SymInt& self_sym_numel, std::vector<c10::SymInt>& self_sym_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (mean_backward(grad, self_sym_sizes, dim, self_sym_numel, keepdim)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list MeanBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<c10::OptionalArray<int64_t>>();
  auto keepdim = packed_args.unpack<bool>();
  auto self_sym_numel = packed_args.unpack<c10::SymInt>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return MeanBackward1_apply_functional(variable_list(grads), needs_input_grad, dim, keepdim, self_sym_numel, self_sym_sizes);
#endif
}

variable_list MeanBackward1::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return MeanBackward1_apply_functional(std::move(grads), needs_input_grad, dim, keepdim, self_sym_numel, self_sym_sizes);
}

void MeanBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(keepdim);
    args.collect(self_sym_numel);
    args.collect(self_sym_sizes);
}
variable_list MeanBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(keepdim);
  saved.before(self_sym_numel);
  saved.before(self_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::OptionalArray<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MeanBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(keepdim);
  packed_args.pack(self_sym_numel);
  packed_args.pack(self_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(keepdim);
  saved.after(self_sym_numel);
  saved.after(self_sym_sizes);
  return output_result;
#endif
}

static variable_list MedianBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (evenly_distribute_backward(grad, self, result)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list MedianBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  auto result = packed_args.unpack<Tensor>();
  return MedianBackward0_apply_functional(variable_list(grads), needs_input_grad, self, result);
#endif
}

variable_list MedianBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return MedianBackward0_apply_functional(std::move(grads), needs_input_grad, self, result);
}

void MedianBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
    args.collect(result_, true);
}
variable_list MedianBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MedianBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list NanmedianBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (evenly_distribute_backward(grad, self, result)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list NanmedianBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  auto result = packed_args.unpack<Tensor>();
  return NanmedianBackward0_apply_functional(variable_list(grads), needs_input_grad, self, result);
#endif
}

variable_list NanmedianBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return NanmedianBackward0_apply_functional(std::move(grads), needs_input_grad, self, result);
}

void NanmedianBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
    args.collect(result_, true);
}
variable_list NanmedianBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), NanmedianBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list MedianBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim, bool& keepdim, std::vector<c10::SymInt>& self_sym_sizes, Tensor& indices)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (value_selecting_reduction_backward_symint(grad, dim, indices, self_sym_sizes, keepdim)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list MedianBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  auto keepdim = packed_args.unpack<bool>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  auto indices = packed_args.unpack<Tensor>();
  return MedianBackward1_apply_functional(variable_list(grads), needs_input_grad, dim, keepdim, self_sym_sizes, indices);
#endif
}

variable_list MedianBackward1::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto indices = indices_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return MedianBackward1_apply_functional(std::move(grads), needs_input_grad, dim, keepdim, self_sym_sizes, indices);
}

void MedianBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(keepdim);
    args.collect(self_sym_sizes);
    args.collect(indices_, true);
}
variable_list MedianBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(keepdim);
  saved.before(self_sym_sizes);
  saved.before(indices_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MedianBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto indices = indices_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(keepdim);
  packed_args.pack(self_sym_sizes);
  packed_args.pack(indices);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(keepdim);
  saved.after(self_sym_sizes);
  saved.after(indices_);
  return output_result;
#endif
}

static variable_list NanmedianBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim, bool& keepdim, std::vector<c10::SymInt>& self_sym_sizes, Tensor& indices)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (value_selecting_reduction_backward_symint(grad, dim, indices, self_sym_sizes, keepdim)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list NanmedianBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  auto keepdim = packed_args.unpack<bool>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  auto indices = packed_args.unpack<Tensor>();
  return NanmedianBackward1_apply_functional(variable_list(grads), needs_input_grad, dim, keepdim, self_sym_sizes, indices);
#endif
}

variable_list NanmedianBackward1::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto indices = indices_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return NanmedianBackward1_apply_functional(std::move(grads), needs_input_grad, dim, keepdim, self_sym_sizes, indices);
}

void NanmedianBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(keepdim);
    args.collect(self_sym_sizes);
    args.collect(indices_, true);
}
variable_list NanmedianBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(keepdim);
  saved.before(self_sym_sizes);
  saved.before(indices_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), NanmedianBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto indices = indices_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(keepdim);
  packed_args.pack(self_sym_sizes);
  packed_args.pack(indices);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(keepdim);
  saved.after(self_sym_sizes);
  saved.after(indices_);
  return output_result;
#endif
}

static variable_list MinBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim, bool& keepdim, std::vector<c10::SymInt>& self_sym_sizes, Tensor& indices)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (value_selecting_reduction_backward_symint(grad, dim, indices, self_sym_sizes, keepdim)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list MinBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  auto keepdim = packed_args.unpack<bool>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  auto indices = packed_args.unpack<Tensor>();
  return MinBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, keepdim, self_sym_sizes, indices);
#endif
}

variable_list MinBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto indices = indices_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return MinBackward0_apply_functional(std::move(grads), needs_input_grad, dim, keepdim, self_sym_sizes, indices);
}

void MinBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(keepdim);
    args.collect(self_sym_sizes);
    args.collect(indices_, true);
}
variable_list MinBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(keepdim);
  saved.before(self_sym_sizes);
  saved.before(indices_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MinBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto indices = indices_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(keepdim);
  packed_args.pack(self_sym_sizes);
  packed_args.pack(indices);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(keepdim);
  saved.after(self_sym_sizes);
  saved.after(indices_);
  return output_result;
#endif
}

static variable_list MinBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (evenly_distribute_backward(grad, self, result)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list MinBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  auto result = packed_args.unpack<Tensor>();
  return MinBackward1_apply_functional(variable_list(grads), needs_input_grad, self, result);
#endif
}

variable_list MinBackward1::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return MinBackward1_apply_functional(std::move(grads), needs_input_grad, self, result);
}

void MinBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
    args.collect(result_, true);
}
variable_list MinBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MinBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list MinimumBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& other, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*other*/1]) {
    auto grad_result = any_grad_defined ? (at::where(self == other, grad / 2, grad).masked_fill_(self < other, 0)) : Tensor();
    copy_range(grad_inputs, other_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (at::where(self == other, grad / 2, grad).masked_fill_(self > other, 0)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list MinimumBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto other = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<Tensor>();
  return MinimumBackward0_apply_functional(variable_list(grads), needs_input_grad, other, self);
#endif
}

variable_list MinimumBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto other = other_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  return MinimumBackward0_apply_functional(std::move(grads), needs_input_grad, other, self);
}

void MinimumBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(other_, false);
    args.collect(self_, false);
}
variable_list MinimumBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(other_);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MinimumBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto other = other_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(other);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(other_);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list FminBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& other, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*other*/1]) {
    auto grad_result = any_grad_defined ? (grad.masked_fill((self <= other).logical_or_(other.isnan()), 0)) : Tensor();
    copy_range(grad_inputs, other_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.masked_fill((self <= other).logical_or_(other.isnan()).logical_not_(), 0)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list FminBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto other = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<Tensor>();
  return FminBackward0_apply_functional(variable_list(grads), needs_input_grad, other, self);
#endif
}

variable_list FminBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto other = other_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  return FminBackward0_apply_functional(std::move(grads), needs_input_grad, other, self);
}

void FminBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(other_, false);
    args.collect(self_, false);
}
variable_list FminBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(other_);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), FminBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto other = other_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(other);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(other_);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list AmaxBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<int64_t>& dim, bool& keepdim, Tensor& self, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (scale_grad_by_count(restore_reduced_dims(grad, dim, keepdim), restore_reduced_dims(result, dim, keepdim) == self, dim)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list AmaxBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<std::vector<int64_t>>();
  auto keepdim = packed_args.unpack<bool>();
  auto self = packed_args.unpack<Tensor>();
  auto result = packed_args.unpack<Tensor>();
  return AmaxBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, keepdim, self, result);
#endif
}

variable_list AmaxBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return AmaxBackward0_apply_functional(std::move(grads), needs_input_grad, dim, keepdim, self, result);
}

void AmaxBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(keepdim);
    args.collect(self_, false);
    args.collect(result_, true);
}
variable_list AmaxBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(keepdim);
  saved.before(self_);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), AmaxBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(keepdim);
  packed_args.pack(self);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(keepdim);
  saved.after(self_);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list AminBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<int64_t>& dim, bool& keepdim, Tensor& self, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (scale_grad_by_count(restore_reduced_dims(grad, dim, keepdim), restore_reduced_dims(result, dim, keepdim) == self, dim)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list AminBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<std::vector<int64_t>>();
  auto keepdim = packed_args.unpack<bool>();
  auto self = packed_args.unpack<Tensor>();
  auto result = packed_args.unpack<Tensor>();
  return AminBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, keepdim, self, result);
#endif
}

variable_list AminBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return AminBackward0_apply_functional(std::move(grads), needs_input_grad, dim, keepdim, self, result);
}

void AminBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(keepdim);
    args.collect(self_, false);
    args.collect(result_, true);
}
variable_list AminBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(keepdim);
  saved.before(self_);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), AminBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(keepdim);
  packed_args.pack(self);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(keepdim);
  saved.after(self_);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list MmBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& mat2, at::Layout& mat2_layout, std::vector<c10::SymInt>& mat2_sym_sizes, std::vector<c10::SymInt>& mat2_sym_strides, Tensor& self, at::Layout& self_layout, std::vector<c10::SymInt>& self_sym_sizes, std::vector<c10::SymInt>& self_sym_strides)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto mat2_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*mat2*/1]) {
    auto grad_result = any_grad_defined ? (mm_mat2_backward(grad, self, mat2_sym_sizes, mat2_sym_strides, mat2_layout, 1)) : Tensor();
    copy_range(grad_inputs, mat2_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (mm_mat1_backward(grad, mat2, self_sym_sizes, self_sym_strides, self_layout, 1)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list MmBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto mat2 = packed_args.unpack<Tensor>();
  auto mat2_layout = packed_args.unpack<at::Layout>();
  auto mat2_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  auto mat2_sym_strides = packed_args.unpack<std::vector<c10::SymInt>>();
  auto self = packed_args.unpack<Tensor>();
  auto self_layout = packed_args.unpack<at::Layout>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  auto self_sym_strides = packed_args.unpack<std::vector<c10::SymInt>>();
  return MmBackward0_apply_functional(variable_list(grads), needs_input_grad, mat2, mat2_layout, mat2_sym_sizes, mat2_sym_strides, self, self_layout, self_sym_sizes, self_sym_strides);
#endif
}

variable_list MmBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto mat2 = mat2_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto mat2_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ mat2_ix }),
  };
  return MmBackward0_apply_functional(std::move(grads), needs_input_grad, mat2, mat2_layout, mat2_sym_sizes, mat2_sym_strides, self, self_layout, self_sym_sizes, self_sym_strides);
}

void MmBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(mat2_, false);
    args.collect(mat2_layout);
    args.collect(mat2_sym_sizes);
    args.collect(mat2_sym_strides);
    args.collect(self_, false);
    args.collect(self_layout);
    args.collect(self_sym_sizes);
    args.collect(self_sym_strides);
}
variable_list MmBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(mat2_);
  saved.before(mat2_layout);
  saved.before(mat2_sym_sizes);
  saved.before(mat2_sym_strides);
  saved.before(self_);
  saved.before(self_layout);
  saved.before(self_sym_sizes);
  saved.before(self_sym_strides);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Layout>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Layout>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MmBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto mat2 = mat2_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto mat2_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ mat2_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(mat2);
  packed_args.pack(mat2_layout);
  packed_args.pack(mat2_sym_sizes);
  packed_args.pack(mat2_sym_strides);
  packed_args.pack(self);
  packed_args.pack(self_layout);
  packed_args.pack(self_sym_sizes);
  packed_args.pack(self_sym_strides);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(mat2_);
  saved.after(mat2_layout);
  saved.after(mat2_sym_sizes);
  saved.after(mat2_sym_strides);
  saved.after(self_);
  saved.after(self_layout);
  saved.after(self_sym_sizes);
  saved.after(self_sym_strides);
  return output_result;
#endif
}

static variable_list ModeBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim, bool& keepdim, std::vector<c10::SymInt>& self_sym_sizes, Tensor& indices)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (value_selecting_reduction_backward_symint(grad, dim, indices, self_sym_sizes, keepdim)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ModeBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  auto keepdim = packed_args.unpack<bool>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  auto indices = packed_args.unpack<Tensor>();
  return ModeBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, keepdim, self_sym_sizes, indices);
#endif
}

variable_list ModeBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto indices = indices_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ModeBackward0_apply_functional(std::move(grads), needs_input_grad, dim, keepdim, self_sym_sizes, indices);
}

void ModeBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(keepdim);
    args.collect(self_sym_sizes);
    args.collect(indices_, true);
}
variable_list ModeBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(keepdim);
  saved.before(self_sym_sizes);
  saved.before(indices_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ModeBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto indices = indices_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(keepdim);
  packed_args.pack(self_sym_sizes);
  packed_args.pack(indices);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(keepdim);
  saved.after(self_sym_sizes);
  saved.after(indices_);
  return output_result;
#endif
}

static variable_list MulBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& other, at::ScalarType& other_scalar_type, Tensor& self, at::ScalarType& self_scalar_type)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*other*/1]) {
    auto grad_result = any_grad_defined ? (mul_tensor_backward(grad, self, other_scalar_type)) : Tensor();
    copy_range(grad_inputs, other_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (mul_tensor_backward(grad, other, self_scalar_type)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list MulBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto other = packed_args.unpack<Tensor>();
  auto other_scalar_type = packed_args.unpack<at::ScalarType>();
  auto self = packed_args.unpack<Tensor>();
  auto self_scalar_type = packed_args.unpack<at::ScalarType>();
  return MulBackward0_apply_functional(variable_list(grads), needs_input_grad, other, other_scalar_type, self, self_scalar_type);
#endif
}

variable_list MulBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto other = other_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  return MulBackward0_apply_functional(std::move(grads), needs_input_grad, other, other_scalar_type, self, self_scalar_type);
}

void MulBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(other_, false);
    args.collect(other_scalar_type);
    args.collect(self_, false);
    args.collect(self_scalar_type);
}
variable_list MulBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(other_);
  saved.before(other_scalar_type);
  saved.before(self_);
  saved.before(self_scalar_type);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::ScalarType>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::ScalarType>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MulBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto other = other_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(other);
  packed_args.pack(other_scalar_type);
  packed_args.pack(self);
  packed_args.pack(self_scalar_type);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(other_);
  saved.after(other_scalar_type);
  saved.after(self_);
  saved.after(self_scalar_type);
  return output_result;
#endif
}

static variable_list MulBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, at::Scalar& other, at::ScalarType& self_scalar_type)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (mul_tensor_backward(grad, other, self_scalar_type)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list MulBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto other = packed_args.unpack<at::Scalar>();
  auto self_scalar_type = packed_args.unpack<at::ScalarType>();
  return MulBackward1_apply_functional(variable_list(grads), needs_input_grad, other, self_scalar_type);
#endif
}

variable_list MulBackward1::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return MulBackward1_apply_functional(std::move(grads), needs_input_grad, other, self_scalar_type);
}

void MulBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(other);
    args.collect(self_scalar_type);
}
variable_list MulBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(other);
  saved.before(self_scalar_type);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::ScalarType>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MulBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(other);
  packed_args.pack(self_scalar_type);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(other);
  saved.after(self_scalar_type);
  return output_result;
#endif
}

static variable_list MvBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& self, Tensor& vec)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto vec_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.ger(vec.conj())) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  if (needs_input_grad[/*vec*/1]) {
    auto grad_result = any_grad_defined ? (self.conj().t().mv(grad)) : Tensor();
    copy_range(grad_inputs, vec_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list MvBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto self = packed_args.unpack<Tensor>();
  auto vec = packed_args.unpack<Tensor>();
  return MvBackward0_apply_functional(variable_list(grads), needs_input_grad, self, vec);
#endif
}

variable_list MvBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto vec = vec_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto vec_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ vec_ix }),
  };
  return MvBackward0_apply_functional(std::move(grads), needs_input_grad, self, vec);
}

void MvBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
    args.collect(vec_, false);
}
variable_list MvBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);
  saved.before(vec_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MvBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto vec = vec_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto vec_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ vec_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);
  packed_args.pack(vec);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  saved.after(vec_);
  return output_result;
#endif
}

static variable_list MvlgammaBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& p, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (mvlgamma_backward(grad, self, p)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list MvlgammaBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto p = packed_args.unpack<int64_t>();
  auto self = packed_args.unpack<Tensor>();
  return MvlgammaBackward0_apply_functional(variable_list(grads), needs_input_grad, p, self);
#endif
}

variable_list MvlgammaBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return MvlgammaBackward0_apply_functional(std::move(grads), needs_input_grad, p, self);
}

void MvlgammaBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(p);
    args.collect(self_, false);
}
variable_list MvlgammaBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(p);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MvlgammaBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(p);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(p);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list NanToNumBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad * at::isfinite(self)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list NanToNumBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  return NanToNumBackward0_apply_functional(variable_list(grads), needs_input_grad, self);
#endif
}

variable_list NanToNumBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return NanToNumBackward0_apply_functional(std::move(grads), needs_input_grad, self);
}

void NanToNumBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list NanToNumBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), NanToNumBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list NativeBatchNormBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, double& eps, Tensor& input, Tensor& running_mean, Tensor& running_var, bool& training, Tensor& weight, Tensor& result1, Tensor& result2)
{
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1] || needs_input_grad[2]) {
      auto grad_input_mask = std::array<bool, 3>{
        needs_input_grad[0],
        needs_input_grad[1],
        needs_input_grad[2],
      };
    auto grad_result = grad.defined() ? native_batch_norm_backward(grad, input, weight, running_mean, running_var, result1, result2, training, eps, grad_input_mask) : std::tuple<Tensor, Tensor, Tensor>();
      if (needs_input_grad[/*input*/0]) {
        copy_range(grad_inputs, input_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*weight*/1]) {
        copy_range(grad_inputs, weight_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*bias*/2]) {
        copy_range(grad_inputs, bias_ix, std::get<2>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list NativeBatchNormBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto eps = packed_args.unpack<double>();
  auto input = packed_args.unpack<Tensor>();
  auto running_mean = packed_args.unpack<Tensor>();
  auto running_var = packed_args.unpack<Tensor>();
  auto training = packed_args.unpack<bool>();
  auto weight = packed_args.unpack<Tensor>();
  auto result1 = packed_args.unpack<Tensor>();
  auto result2 = packed_args.unpack<Tensor>();
  return NativeBatchNormBackward0_apply_functional(variable_list(grads), needs_input_grad, eps, input, running_mean, running_var, training, weight, result1, result2);
#endif
}

variable_list NativeBatchNormBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto input = input_.unpack();
  auto running_mean = running_mean_.unpack();
  auto running_var = running_var_.unpack();
  auto weight = weight_.unpack();
  auto result1 = result1_.unpack(shared_from_this());
  auto result2 = result2_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  return NativeBatchNormBackward0_apply_functional(std::move(grads), needs_input_grad, eps, input, running_mean, running_var, training, weight, result1, result2);
}

void NativeBatchNormBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(eps);
    args.collect(input_, false);
    args.collect(running_mean_, false);
    args.collect(running_var_, false);
    args.collect(training);
    args.collect(weight_, false);
    args.collect(result1_, true);
    args.collect(result2_, true);
}
variable_list NativeBatchNormBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(eps);
  saved.before(input_);
  saved.before(running_mean_);
  saved.before(running_var_);
  saved.before(training);
  saved.before(weight_);
  saved.before(result1_);
  saved.before(result2_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<double>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), NativeBatchNormBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto input = input_.unpack();
  auto running_mean = running_mean_.unpack();
  auto running_var = running_var_.unpack();
  auto weight = weight_.unpack();
  auto result1 = result1_.unpack(shared_from_this());
  auto result2 = result2_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(eps);
  packed_args.pack(input);
  packed_args.pack(running_mean);
  packed_args.pack(running_var);
  packed_args.pack(training);
  packed_args.pack(weight);
  packed_args.pack(result1);
  packed_args.pack(result2);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(eps);
  saved.after(input_);
  saved.after(running_mean_);
  saved.after(running_var_);
  saved.after(training);
  saved.after(weight_);
  saved.after(result1_);
  saved.after(result2_);
  return output_result;
#endif
}

static variable_list NativeBatchNormLegitBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, double& eps, Tensor& input, Tensor& running_mean, Tensor& running_var, bool& training, Tensor& weight, Tensor& result1, Tensor& result2)
{
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1] || needs_input_grad[2]) {
      auto grad_input_mask = std::array<bool, 3>{
        needs_input_grad[0],
        needs_input_grad[1],
        needs_input_grad[2],
      };
    auto grad_result = grad.defined() ? native_batch_norm_backward(grad, input, weight, running_mean, running_var, result1, result2, training, eps, grad_input_mask) : std::tuple<Tensor, Tensor, Tensor>();
      if (needs_input_grad[/*input*/0]) {
        copy_range(grad_inputs, input_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*weight*/1]) {
        copy_range(grad_inputs, weight_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*bias*/2]) {
        copy_range(grad_inputs, bias_ix, std::get<2>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list NativeBatchNormLegitBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto eps = packed_args.unpack<double>();
  auto input = packed_args.unpack<Tensor>();
  auto running_mean = packed_args.unpack<Tensor>();
  auto running_var = packed_args.unpack<Tensor>();
  auto training = packed_args.unpack<bool>();
  auto weight = packed_args.unpack<Tensor>();
  auto result1 = packed_args.unpack<Tensor>();
  auto result2 = packed_args.unpack<Tensor>();
  return NativeBatchNormLegitBackward0_apply_functional(variable_list(grads), needs_input_grad, eps, input, running_mean, running_var, training, weight, result1, result2);
#endif
}

variable_list NativeBatchNormLegitBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto input = input_.unpack();
  auto running_mean = running_mean_.unpack();
  auto running_var = running_var_.unpack();
  auto weight = weight_.unpack();
  auto result1 = result1_.unpack(shared_from_this());
  auto result2 = result2_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  return NativeBatchNormLegitBackward0_apply_functional(std::move(grads), needs_input_grad, eps, input, running_mean, running_var, training, weight, result1, result2);
}

void NativeBatchNormLegitBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(eps);
    args.collect(input_, false);
    args.collect(running_mean_, false);
    args.collect(running_var_, false);
    args.collect(training);
    args.collect(weight_, false);
    args.collect(result1_, true);
    args.collect(result2_, true);
}
variable_list NativeBatchNormLegitBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(eps);
  saved.before(input_);
  saved.before(running_mean_);
  saved.before(running_var_);
  saved.before(training);
  saved.before(weight_);
  saved.before(result1_);
  saved.before(result2_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<double>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), NativeBatchNormLegitBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto input = input_.unpack();
  auto running_mean = running_mean_.unpack();
  auto running_var = running_var_.unpack();
  auto weight = weight_.unpack();
  auto result1 = result1_.unpack(shared_from_this());
  auto result2 = result2_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(eps);
  packed_args.pack(input);
  packed_args.pack(running_mean);
  packed_args.pack(running_var);
  packed_args.pack(training);
  packed_args.pack(weight);
  packed_args.pack(result1);
  packed_args.pack(result2);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(eps);
  saved.after(input_);
  saved.after(running_mean_);
  saved.after(running_var_);
  saved.after(training);
  saved.after(weight_);
  saved.after(result1_);
  saved.after(result2_);
  return output_result;
#endif
}

static variable_list NativeBatchNormLegitNoTrainingBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, double& eps, Tensor& input, Tensor& running_mean, Tensor& running_var, Tensor& weight, Tensor& result1, Tensor& result2)
{
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1] || needs_input_grad[2]) {
      auto grad_input_mask = std::array<bool, 3>{
        needs_input_grad[0],
        needs_input_grad[1],
        needs_input_grad[2],
      };
    auto grad_result = grad.defined() ? native_batch_norm_backward(grad, input, weight, running_mean, running_var, result1, result2, /*training=*/false, eps, grad_input_mask) : std::tuple<Tensor, Tensor, Tensor>();
      if (needs_input_grad[/*input*/0]) {
        copy_range(grad_inputs, input_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*weight*/1]) {
        copy_range(grad_inputs, weight_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*bias*/2]) {
        copy_range(grad_inputs, bias_ix, std::get<2>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list NativeBatchNormLegitNoTrainingBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto eps = packed_args.unpack<double>();
  auto input = packed_args.unpack<Tensor>();
  auto running_mean = packed_args.unpack<Tensor>();
  auto running_var = packed_args.unpack<Tensor>();
  auto weight = packed_args.unpack<Tensor>();
  auto result1 = packed_args.unpack<Tensor>();
  auto result2 = packed_args.unpack<Tensor>();
  return NativeBatchNormLegitNoTrainingBackward0_apply_functional(variable_list(grads), needs_input_grad, eps, input, running_mean, running_var, weight, result1, result2);
#endif
}

variable_list NativeBatchNormLegitNoTrainingBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto input = input_.unpack();
  auto running_mean = running_mean_.unpack();
  auto running_var = running_var_.unpack();
  auto weight = weight_.unpack();
  auto result1 = result1_.unpack(shared_from_this());
  auto result2 = result2_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  return NativeBatchNormLegitNoTrainingBackward0_apply_functional(std::move(grads), needs_input_grad, eps, input, running_mean, running_var, weight, result1, result2);
}

void NativeBatchNormLegitNoTrainingBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(eps);
    args.collect(input_, false);
    args.collect(running_mean_, false);
    args.collect(running_var_, false);
    args.collect(weight_, false);
    args.collect(result1_, true);
    args.collect(result2_, true);
}
variable_list NativeBatchNormLegitNoTrainingBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(eps);
  saved.before(input_);
  saved.before(running_mean_);
  saved.before(running_var_);
  saved.before(weight_);
  saved.before(result1_);
  saved.before(result2_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<double>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), NativeBatchNormLegitNoTrainingBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto input = input_.unpack();
  auto running_mean = running_mean_.unpack();
  auto running_var = running_var_.unpack();
  auto weight = weight_.unpack();
  auto result1 = result1_.unpack(shared_from_this());
  auto result2 = result2_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(eps);
  packed_args.pack(input);
  packed_args.pack(running_mean);
  packed_args.pack(running_var);
  packed_args.pack(weight);
  packed_args.pack(result1);
  packed_args.pack(result2);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(eps);
  saved.after(input_);
  saved.after(running_mean_);
  saved.after(running_var_);
  saved.after(weight_);
  saved.after(result1_);
  saved.after(result2_);
  return output_result;
#endif
}

static variable_list NativeBatchNormLegitBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, double& eps, Tensor& input, bool& training, Tensor& weight, Tensor& result1, Tensor& result2)
{
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1] || needs_input_grad[2]) {
      auto grad_input_mask = std::array<bool, 3>{
        needs_input_grad[0],
        needs_input_grad[1],
        needs_input_grad[2],
      };
    auto grad_result = grad.defined() ? native_batch_norm_backward(grad, input, weight, Tensor(), Tensor(), result1, result2, training, eps, grad_input_mask) : std::tuple<Tensor, Tensor, Tensor>();
      if (needs_input_grad[/*input*/0]) {
        copy_range(grad_inputs, input_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*weight*/1]) {
        copy_range(grad_inputs, weight_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*bias*/2]) {
        copy_range(grad_inputs, bias_ix, std::get<2>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list NativeBatchNormLegitBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto eps = packed_args.unpack<double>();
  auto input = packed_args.unpack<Tensor>();
  auto training = packed_args.unpack<bool>();
  auto weight = packed_args.unpack<Tensor>();
  auto result1 = packed_args.unpack<Tensor>();
  auto result2 = packed_args.unpack<Tensor>();
  return NativeBatchNormLegitBackward1_apply_functional(variable_list(grads), needs_input_grad, eps, input, training, weight, result1, result2);
#endif
}

variable_list NativeBatchNormLegitBackward1::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto input = input_.unpack();
  auto weight = weight_.unpack();
  auto result1 = result1_.unpack(shared_from_this());
  auto result2 = result2_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  return NativeBatchNormLegitBackward1_apply_functional(std::move(grads), needs_input_grad, eps, input, training, weight, result1, result2);
}

void NativeBatchNormLegitBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(eps);
    args.collect(input_, false);
    args.collect(training);
    args.collect(weight_, false);
    args.collect(result1_, true);
    args.collect(result2_, true);
}
variable_list NativeBatchNormLegitBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(eps);
  saved.before(input_);
  saved.before(training);
  saved.before(weight_);
  saved.before(result1_);
  saved.before(result2_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<double>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), NativeBatchNormLegitBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto input = input_.unpack();
  auto weight = weight_.unpack();
  auto result1 = result1_.unpack(shared_from_this());
  auto result2 = result2_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(eps);
  packed_args.pack(input);
  packed_args.pack(training);
  packed_args.pack(weight);
  packed_args.pack(result1);
  packed_args.pack(result2);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(eps);
  saved.after(input_);
  saved.after(training);
  saved.after(weight_);
  saved.after(result1_);
  saved.after(result2_);
  return output_result;
#endif
}

static variable_list NativeBatchNormBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,5> needs_input_grad, double& eps, Tensor& grad_out, Tensor& input, Tensor& running_mean, Tensor& running_var, Tensor& save_invstd, Tensor& save_mean, bool& train, Tensor& weight)
{
  IndexRangeGenerator gen;
  auto grad_out_ix = gen.range(1);
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto save_mean_ix = gen.range(1);
  auto save_invstd_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[1] || needs_input_grad[2] || needs_input_grad[0]) {
      auto grad_input_mask = std::array<bool, 3>{
        needs_input_grad[1],
        needs_input_grad[2],
        needs_input_grad[0],
      };
    auto grad_result = batchnorm_double_backward(input, weight, grads[0], grads[1], grads[2], grad_out, running_mean, running_var, train, eps, save_mean, save_invstd, grad_input_mask);
      if (needs_input_grad[/*input*/1]) {
        copy_range(grad_inputs, input_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*weight*/2]) {
        copy_range(grad_inputs, weight_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*grad_out*/0]) {
        copy_range(grad_inputs, grad_out_ix, std::get<2>(grad_result));
      }
  }
  if (needs_input_grad[/*save_invstd*/4]) {
    auto grad_result = not_implemented("native_batch_norm_backward save_invstd");
    copy_range(grad_inputs, save_invstd_ix, grad_result);
  }
  if (needs_input_grad[/*save_mean*/3]) {
    auto grad_result = not_implemented("native_batch_norm_backward save_mean");
    copy_range(grad_inputs, save_mean_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list NativeBatchNormBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 5>>();
  auto eps = packed_args.unpack<double>();
  auto grad_out = packed_args.unpack<Tensor>();
  auto input = packed_args.unpack<Tensor>();
  auto running_mean = packed_args.unpack<Tensor>();
  auto running_var = packed_args.unpack<Tensor>();
  auto save_invstd = packed_args.unpack<Tensor>();
  auto save_mean = packed_args.unpack<Tensor>();
  auto train = packed_args.unpack<bool>();
  auto weight = packed_args.unpack<Tensor>();
  return NativeBatchNormBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, eps, grad_out, input, running_mean, running_var, save_invstd, save_mean, train, weight);
#endif
}

variable_list NativeBatchNormBackwardBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto grad_out = grad_out_.unpack();
  auto input = input_.unpack();
  auto running_mean = running_mean_.unpack();
  auto running_var = running_var_.unpack();
  auto save_invstd = save_invstd_.unpack();
  auto save_mean = save_mean_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto grad_out_ix = gen.range(1);
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto save_mean_ix = gen.range(1);
  auto save_invstd_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 5>{
    task_should_compute_output({ grad_out_ix }),
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ save_mean_ix }),
    task_should_compute_output({ save_invstd_ix }),
  };
  return NativeBatchNormBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, eps, grad_out, input, running_mean, running_var, save_invstd, save_mean, train, weight);
}

void NativeBatchNormBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(eps);
    args.collect(grad_out_, false);
    args.collect(input_, false);
    args.collect(running_mean_, false);
    args.collect(running_var_, false);
    args.collect(save_invstd_, false);
    args.collect(save_mean_, false);
    args.collect(train);
    args.collect(weight_, false);
}
variable_list NativeBatchNormBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(eps);
  saved.before(grad_out_);
  saved.before(input_);
  saved.before(running_mean_);
  saved.before(running_var_);
  saved.before(save_invstd_);
  saved.before(save_mean_);
  saved.before(train);
  saved.before(weight_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 5>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<double>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), NativeBatchNormBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto grad_out = grad_out_.unpack();
  auto input = input_.unpack();
  auto running_mean = running_mean_.unpack();
  auto running_var = running_var_.unpack();
  auto save_invstd = save_invstd_.unpack();
  auto save_mean = save_mean_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto grad_out_ix = gen.range(1);
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto save_mean_ix = gen.range(1);
  auto save_invstd_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 5>{
    task_should_compute_output({ grad_out_ix }),
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ save_mean_ix }),
    task_should_compute_output({ save_invstd_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(eps);
  packed_args.pack(grad_out);
  packed_args.pack(input);
  packed_args.pack(running_mean);
  packed_args.pack(running_var);
  packed_args.pack(save_invstd);
  packed_args.pack(save_mean);
  packed_args.pack(train);
  packed_args.pack(weight);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(eps);
  saved.after(grad_out_);
  saved.after(input_);
  saved.after(running_mean_);
  saved.after(running_var_);
  saved.after(save_invstd_);
  saved.after(save_mean_);
  saved.after(train);
  saved.after(weight_);
  return output_result;
#endif
}

static variable_list NativeLayerNormBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, Tensor& bias, Tensor& input, std::vector<c10::SymInt>& normalized_shape, Tensor& weight, Tensor& result1, Tensor& result2)
{
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1] || needs_input_grad[2]) {
      auto grad_input_mask = std::array<bool, 3>{
        needs_input_grad[0],
        needs_input_grad[1],
        needs_input_grad[2],
      };
    auto grad_result = grad.defined() ? native_layer_norm_backward_symint(grad, input, normalized_shape, result1, result2, weight, bias, grad_input_mask) : std::tuple<Tensor, Tensor, Tensor>();
      if (needs_input_grad[/*input*/0]) {
        copy_range(grad_inputs, input_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*weight*/1]) {
        copy_range(grad_inputs, weight_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*bias*/2]) {
        copy_range(grad_inputs, bias_ix, std::get<2>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list NativeLayerNormBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto bias = packed_args.unpack<Tensor>();
  auto input = packed_args.unpack<Tensor>();
  auto normalized_shape = packed_args.unpack<std::vector<c10::SymInt>>();
  auto weight = packed_args.unpack<Tensor>();
  auto result1 = packed_args.unpack<Tensor>();
  auto result2 = packed_args.unpack<Tensor>();
  return NativeLayerNormBackward0_apply_functional(variable_list(grads), needs_input_grad, bias, input, normalized_shape, weight, result1, result2);
#endif
}

variable_list NativeLayerNormBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto bias = bias_.unpack();
  auto input = input_.unpack();
  auto weight = weight_.unpack();
  auto result1 = result1_.unpack(shared_from_this());
  auto result2 = result2_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  return NativeLayerNormBackward0_apply_functional(std::move(grads), needs_input_grad, bias, input, normalized_shape, weight, result1, result2);
}

void NativeLayerNormBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(bias_, false);
    args.collect(input_, false);
    args.collect(normalized_shape);
    args.collect(weight_, false);
    args.collect(result1_, true);
    args.collect(result2_, true);
}
variable_list NativeLayerNormBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(bias_);
  saved.before(input_);
  saved.before(normalized_shape);
  saved.before(weight_);
  saved.before(result1_);
  saved.before(result2_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), NativeLayerNormBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto bias = bias_.unpack();
  auto input = input_.unpack();
  auto weight = weight_.unpack();
  auto result1 = result1_.unpack(shared_from_this());
  auto result2 = result2_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(bias);
  packed_args.pack(input);
  packed_args.pack(normalized_shape);
  packed_args.pack(weight);
  packed_args.pack(result1);
  packed_args.pack(result2);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(bias_);
  saved.after(input_);
  saved.after(normalized_shape);
  saved.after(weight_);
  saved.after(result1_);
  saved.after(result2_);
  return output_result;
#endif
}

static variable_list NativeLayerNormBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,6> needs_input_grad, Tensor& grad_out, Tensor& input, Tensor& mean, std::vector<c10::SymInt>& normalized_shape, Tensor& rstd, Tensor& weight)
{
  IndexRangeGenerator gen;
  auto grad_out_ix = gen.range(1);
  auto input_ix = gen.range(1);
  auto mean_ix = gen.range(1);
  auto rstd_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*bias*/5]) {
    auto grad_result = any_grad_defined ? (Tensor()) : Tensor();
    copy_range(grad_inputs, bias_ix, grad_result);
  }
  if (needs_input_grad[1] || needs_input_grad[4] || needs_input_grad[0]) {
      auto grad_input_mask = std::array<bool, 3>{
        needs_input_grad[1],
        needs_input_grad[4],
        needs_input_grad[0],
      };
    auto grad_result = layer_norm_double_backward(input, weight, grads[0], grads[1], grads[2], grad_out, mean, rstd, normalized_shape, grad_input_mask);
      if (needs_input_grad[/*input*/1]) {
        copy_range(grad_inputs, input_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*weight*/4]) {
        copy_range(grad_inputs, weight_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*grad_out*/0]) {
        copy_range(grad_inputs, grad_out_ix, std::get<2>(grad_result));
      }
  }
  if (needs_input_grad[/*mean*/2]) {
    auto grad_result = not_implemented("native_layer_norm_backward mean");
    copy_range(grad_inputs, mean_ix, grad_result);
  }
  if (needs_input_grad[/*rstd*/3]) {
    auto grad_result = not_implemented("native_layer_norm_backward rstd");
    copy_range(grad_inputs, rstd_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list NativeLayerNormBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 6>>();
  auto grad_out = packed_args.unpack<Tensor>();
  auto input = packed_args.unpack<Tensor>();
  auto mean = packed_args.unpack<Tensor>();
  auto normalized_shape = packed_args.unpack<std::vector<c10::SymInt>>();
  auto rstd = packed_args.unpack<Tensor>();
  auto weight = packed_args.unpack<Tensor>();
  return NativeLayerNormBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, grad_out, input, mean, normalized_shape, rstd, weight);
#endif
}

variable_list NativeLayerNormBackwardBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto grad_out = grad_out_.unpack();
  auto input = input_.unpack();
  auto mean = mean_.unpack();
  auto rstd = rstd_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto grad_out_ix = gen.range(1);
  auto input_ix = gen.range(1);
  auto mean_ix = gen.range(1);
  auto rstd_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 6>{
    task_should_compute_output({ grad_out_ix }),
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ mean_ix }),
    task_should_compute_output({ rstd_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  return NativeLayerNormBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, grad_out, input, mean, normalized_shape, rstd, weight);
}

void NativeLayerNormBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(grad_out_, false);
    args.collect(input_, false);
    args.collect(mean_, false);
    args.collect(normalized_shape);
    args.collect(rstd_, false);
    args.collect(weight_, false);
}
variable_list NativeLayerNormBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(grad_out_);
  saved.before(input_);
  saved.before(mean_);
  saved.before(normalized_shape);
  saved.before(rstd_);
  saved.before(weight_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 6>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), NativeLayerNormBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto grad_out = grad_out_.unpack();
  auto input = input_.unpack();
  auto mean = mean_.unpack();
  auto rstd = rstd_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto grad_out_ix = gen.range(1);
  auto input_ix = gen.range(1);
  auto mean_ix = gen.range(1);
  auto rstd_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 6>{
    task_should_compute_output({ grad_out_ix }),
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ mean_ix }),
    task_should_compute_output({ rstd_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(grad_out);
  packed_args.pack(input);
  packed_args.pack(mean);
  packed_args.pack(normalized_shape);
  packed_args.pack(rstd);
  packed_args.pack(weight);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(grad_out_);
  saved.after(input_);
  saved.after(mean_);
  saved.after(normalized_shape);
  saved.after(rstd_);
  saved.after(weight_);
  return output_result;
#endif
}

static variable_list NativeGroupNormBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, c10::SymInt& C, c10::SymInt& HxW, c10::SymInt& N, double& eps, int64_t& group, Tensor& input, Tensor& weight, Tensor& result1, Tensor& result2)
{
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[0] || needs_input_grad[1] || needs_input_grad[2]) {
      auto grad_input_mask = std::array<bool, 3>{
        needs_input_grad[0],
        needs_input_grad[1],
        needs_input_grad[2],
      };
    auto grad_result = GradMode::is_enabled() || grads[1].defined() || grads[2].defined() ? infinitely_differentiable_native_group_norm_backward(grads[0], grads[1], grads[2], input, result1, result2, weight, N, C, HxW, group, eps, grad_input_mask) : (grads[0].defined() ? native_group_norm_backward_symint(grads[0].device().is_xpu() ? grads[0] : grads[0].contiguous(grads[0].device().is_cpu() ? input.suggest_memory_format() : c10::MemoryFormat::Contiguous), input.device().is_xpu() ? input : input.contiguous(input.device().is_cpu() ? input.suggest_memory_format() : c10::MemoryFormat::Contiguous), result1, result2, weight, N, C, HxW, group, grad_input_mask) : std::tuple<Tensor, Tensor, Tensor>());
      if (needs_input_grad[/*input*/0]) {
        copy_range(grad_inputs, input_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*weight*/1]) {
        copy_range(grad_inputs, weight_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*bias*/2]) {
        copy_range(grad_inputs, bias_ix, std::get<2>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list NativeGroupNormBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto C = packed_args.unpack<c10::SymInt>();
  auto HxW = packed_args.unpack<c10::SymInt>();
  auto N = packed_args.unpack<c10::SymInt>();
  auto eps = packed_args.unpack<double>();
  auto group = packed_args.unpack<int64_t>();
  auto input = packed_args.unpack<Tensor>();
  auto weight = packed_args.unpack<Tensor>();
  auto result1 = packed_args.unpack<Tensor>();
  auto result2 = packed_args.unpack<Tensor>();
  return NativeGroupNormBackward0_apply_functional(variable_list(grads), needs_input_grad, C, HxW, N, eps, group, input, weight, result1, result2);
#endif
}

variable_list NativeGroupNormBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto input = input_.unpack();
  auto weight = weight_.unpack();
  auto result1 = result1_.unpack(shared_from_this());
  auto result2 = result2_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  return NativeGroupNormBackward0_apply_functional(std::move(grads), needs_input_grad, C, HxW, N, eps, group, input, weight, result1, result2);
}

void NativeGroupNormBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(C);
    args.collect(HxW);
    args.collect(N);
    args.collect(eps);
    args.collect(group);
    args.collect(input_, false);
    args.collect(weight_, false);
    args.collect(result1_, true);
    args.collect(result2_, true);
}
variable_list NativeGroupNormBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(C);
  saved.before(HxW);
  saved.before(N);
  saved.before(eps);
  saved.before(group);
  saved.before(input_);
  saved.before(weight_);
  saved.before(result1_);
  saved.before(result2_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<double>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), NativeGroupNormBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto input = input_.unpack();
  auto weight = weight_.unpack();
  auto result1 = result1_.unpack(shared_from_this());
  auto result2 = result2_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(C);
  packed_args.pack(HxW);
  packed_args.pack(N);
  packed_args.pack(eps);
  packed_args.pack(group);
  packed_args.pack(input);
  packed_args.pack(weight);
  packed_args.pack(result1);
  packed_args.pack(result2);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(C);
  saved.after(HxW);
  saved.after(N);
  saved.after(eps);
  saved.after(group);
  saved.after(input_);
  saved.after(weight_);
  saved.after(result1_);
  saved.after(result2_);
  return output_result;
#endif
}

static variable_list NeBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, torch::autograd::generated::TypeAndSize& self_info)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (self_info.zeros()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list NeBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_info = packed_args.unpack<torch::autograd::generated::TypeAndSize>();
  return NeBackward0_apply_functional(variable_list(grads), needs_input_grad, self_info);
#endif
}

variable_list NeBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return NeBackward0_apply_functional(std::move(grads), needs_input_grad, self_info);
}

void NeBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_info);
}
variable_list NeBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_info);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::autograd::generated::TypeAndSize>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), NeBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_info);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_info);
  return output_result;
#endif
}

static variable_list NeBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, torch::autograd::generated::TypeAndSize& other_info, torch::autograd::generated::TypeAndSize& self_info)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*other*/1]) {
    auto grad_result = any_grad_defined ? (other_info.zeros()) : Tensor();
    copy_range(grad_inputs, other_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (self_info.zeros()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list NeBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto other_info = packed_args.unpack<torch::autograd::generated::TypeAndSize>();
  auto self_info = packed_args.unpack<torch::autograd::generated::TypeAndSize>();
  return NeBackward1_apply_functional(variable_list(grads), needs_input_grad, other_info, self_info);
#endif
}

variable_list NeBackward1::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  return NeBackward1_apply_functional(std::move(grads), needs_input_grad, other_info, self_info);
}

void NeBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(other_info);
    args.collect(self_info);
}
variable_list NeBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(other_info);
  saved.before(self_info);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::autograd::generated::TypeAndSize>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::autograd::generated::TypeAndSize>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), NeBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(other_info);
  packed_args.pack(self_info);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(other_info);
  saved.after(self_info);
  return output_result;
#endif
}

static variable_list NegBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.neg()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list NegBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return NegBackward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list NegBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return NegBackward0_apply_functional(std::move(grads), needs_input_grad);
}

void NegBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list NegBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), NegBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list BatchNormWithUpdateBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, double& eps, Tensor& input, Tensor& running_mean, Tensor& running_var, Tensor& weight, Tensor& result1, Tensor& result2, Tensor& result3, bool retain_variables)
{
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1] || needs_input_grad[2]) {
      auto grad_input_mask = std::array<bool, 3>{
        needs_input_grad[0],
        needs_input_grad[1],
        needs_input_grad[2],
      };
    auto grad_result = grad.defined() ? batch_norm_backward(grad, input, weight, running_mean, running_var, result1, result2, /*update*/true, eps, grad_input_mask, retain_variables ? result3.clone() : result3) : std::tuple<Tensor, Tensor, Tensor>();
      if (needs_input_grad[/*input*/0]) {
        copy_range(grad_inputs, input_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*weight*/1]) {
        copy_range(grad_inputs, weight_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*bias*/2]) {
        copy_range(grad_inputs, bias_ix, std::get<2>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list BatchNormWithUpdateBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto eps = packed_args.unpack<double>();
  auto input = packed_args.unpack<Tensor>();
  auto running_mean = packed_args.unpack<Tensor>();
  auto running_var = packed_args.unpack<Tensor>();
  auto weight = packed_args.unpack<Tensor>();
  auto result1 = packed_args.unpack<Tensor>();
  auto result2 = packed_args.unpack<Tensor>();
  auto result3 = packed_args.unpack<Tensor>();
  auto retain_variables = packed_args.unpack<bool>();
  return BatchNormWithUpdateBackward0_apply_functional(variable_list(grads), needs_input_grad, eps, input, running_mean, running_var, weight, result1, result2, result3, retain_variables);
#endif
}

variable_list BatchNormWithUpdateBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto input = input_.unpack();
  auto running_mean = running_mean_.unpack();
  auto running_var = running_var_.unpack();
  auto weight = weight_.unpack();
  auto result1 = result1_.unpack(shared_from_this());
  auto result2 = result2_.unpack(shared_from_this());
  auto result3 = result3_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  return BatchNormWithUpdateBackward0_apply_functional(std::move(grads), needs_input_grad, eps, input, running_mean, running_var, weight, result1, result2, result3, retain_variables);
}

void BatchNormWithUpdateBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(eps);
    args.collect(input_, false);
    args.collect(running_mean_, false);
    args.collect(running_var_, false);
    args.collect(weight_, false);
    args.collect(result1_, true);
    args.collect(result2_, true);
    args.collect(result3_, true);
}
variable_list BatchNormWithUpdateBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(eps);
  saved.before(input_);
  saved.before(running_mean_);
  saved.before(running_var_);
  saved.before(weight_);
  saved.before(result1_);
  saved.before(result2_);
  saved.before(result3_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<double>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), BatchNormWithUpdateBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto input = input_.unpack();
  auto running_mean = running_mean_.unpack();
  auto running_var = running_var_.unpack();
  auto weight = weight_.unpack();
  auto result1 = result1_.unpack(shared_from_this());
  auto result2 = result2_.unpack(shared_from_this());
  auto result3 = result3_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(eps);
  packed_args.pack(input);
  packed_args.pack(running_mean);
  packed_args.pack(running_var);
  packed_args.pack(weight);
  packed_args.pack(result1);
  packed_args.pack(result2);
  packed_args.pack(result3);
  packed_args.pack(retain_variables);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(eps);
  saved.after(input_);
  saved.after(running_mean_);
  saved.after(running_var_);
  saved.after(weight_);
  saved.after(result1_);
  saved.after(result2_);
  saved.after(result3_);
  return output_result;
#endif
}

static variable_list BatchNormNoUpdateBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, double& eps, Tensor& input, Tensor& running_mean, Tensor& running_var, Tensor& weight, Tensor& result1, Tensor& result2, Tensor& result3, bool retain_variables)
{
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1] || needs_input_grad[2]) {
      auto grad_input_mask = std::array<bool, 3>{
        needs_input_grad[0],
        needs_input_grad[1],
        needs_input_grad[2],
      };
    auto grad_result = grad.defined() ? batch_norm_backward(grad, input, weight, running_mean, running_var, result1, result2, /*update*/false, eps, grad_input_mask, retain_variables ? result3.clone() : result3) : std::tuple<Tensor, Tensor, Tensor>();
      if (needs_input_grad[/*input*/0]) {
        copy_range(grad_inputs, input_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*weight*/1]) {
        copy_range(grad_inputs, weight_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*bias*/2]) {
        copy_range(grad_inputs, bias_ix, std::get<2>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list BatchNormNoUpdateBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto eps = packed_args.unpack<double>();
  auto input = packed_args.unpack<Tensor>();
  auto running_mean = packed_args.unpack<Tensor>();
  auto running_var = packed_args.unpack<Tensor>();
  auto weight = packed_args.unpack<Tensor>();
  auto result1 = packed_args.unpack<Tensor>();
  auto result2 = packed_args.unpack<Tensor>();
  auto result3 = packed_args.unpack<Tensor>();
  auto retain_variables = packed_args.unpack<bool>();
  return BatchNormNoUpdateBackward0_apply_functional(variable_list(grads), needs_input_grad, eps, input, running_mean, running_var, weight, result1, result2, result3, retain_variables);
#endif
}

variable_list BatchNormNoUpdateBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto input = input_.unpack();
  auto running_mean = running_mean_.unpack();
  auto running_var = running_var_.unpack();
  auto weight = weight_.unpack();
  auto result1 = result1_.unpack(shared_from_this());
  auto result2 = result2_.unpack(shared_from_this());
  auto result3 = result3_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  return BatchNormNoUpdateBackward0_apply_functional(std::move(grads), needs_input_grad, eps, input, running_mean, running_var, weight, result1, result2, result3, retain_variables);
}

void BatchNormNoUpdateBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(eps);
    args.collect(input_, false);
    args.collect(running_mean_, false);
    args.collect(running_var_, false);
    args.collect(weight_, false);
    args.collect(result1_, true);
    args.collect(result2_, true);
    args.collect(result3_, true);
}
variable_list BatchNormNoUpdateBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(eps);
  saved.before(input_);
  saved.before(running_mean_);
  saved.before(running_var_);
  saved.before(weight_);
  saved.before(result1_);
  saved.before(result2_);
  saved.before(result3_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<double>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), BatchNormNoUpdateBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto input = input_.unpack();
  auto running_mean = running_mean_.unpack();
  auto running_var = running_var_.unpack();
  auto weight = weight_.unpack();
  auto result1 = result1_.unpack(shared_from_this());
  auto result2 = result2_.unpack(shared_from_this());
  auto result3 = result3_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(eps);
  packed_args.pack(input);
  packed_args.pack(running_mean);
  packed_args.pack(running_var);
  packed_args.pack(weight);
  packed_args.pack(result1);
  packed_args.pack(result2);
  packed_args.pack(result3);
  packed_args.pack(retain_variables);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(eps);
  saved.after(input_);
  saved.after(running_mean_);
  saved.after(running_var_);
  saved.after(weight_);
  saved.after(result1_);
  saved.after(result2_);
  saved.after(result3_);
  return output_result;
#endif
}

static variable_list BatchNormBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,6> needs_input_grad, double& eps, Tensor& grad_out, Tensor& input, Tensor& reserve, Tensor& running_mean, Tensor& running_var, Tensor& save_mean, Tensor& save_var, bool& update, Tensor& weight)
{
  IndexRangeGenerator gen;
  auto grad_out_ix = gen.range(1);
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto save_mean_ix = gen.range(1);
  auto save_var_ix = gen.range(1);
  auto reserve_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[1] || needs_input_grad[2] || needs_input_grad[0]) {
      auto grad_input_mask = std::array<bool, 3>{
        needs_input_grad[1],
        needs_input_grad[2],
        needs_input_grad[0],
      };
    auto grad_result = batchnorm_double_backward(input, weight, grads[0], grads[1], grads[2], grad_out, running_mean, running_var, update, eps, save_mean, save_var, grad_input_mask);
      if (needs_input_grad[/*input*/1]) {
        copy_range(grad_inputs, input_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*weight*/2]) {
        copy_range(grad_inputs, weight_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*grad_out*/0]) {
        copy_range(grad_inputs, grad_out_ix, std::get<2>(grad_result));
      }
  }
  if (needs_input_grad[/*reserve*/5]) {
    auto grad_result = not_implemented("batch_norm_backward reserve");
    copy_range(grad_inputs, reserve_ix, grad_result);
  }
  if (needs_input_grad[/*save_mean*/3]) {
    auto grad_result = not_implemented("batch_norm_backward save_mean");
    copy_range(grad_inputs, save_mean_ix, grad_result);
  }
  if (needs_input_grad[/*save_var*/4]) {
    auto grad_result = not_implemented("batch_norm_backward save_var");
    copy_range(grad_inputs, save_var_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list BatchNormBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 6>>();
  auto eps = packed_args.unpack<double>();
  auto grad_out = packed_args.unpack<Tensor>();
  auto input = packed_args.unpack<Tensor>();
  auto reserve = packed_args.unpack<Tensor>();
  auto running_mean = packed_args.unpack<Tensor>();
  auto running_var = packed_args.unpack<Tensor>();
  auto save_mean = packed_args.unpack<Tensor>();
  auto save_var = packed_args.unpack<Tensor>();
  auto update = packed_args.unpack<bool>();
  auto weight = packed_args.unpack<Tensor>();
  return BatchNormBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, eps, grad_out, input, reserve, running_mean, running_var, save_mean, save_var, update, weight);
#endif
}

variable_list BatchNormBackwardBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto grad_out = grad_out_.unpack();
  auto input = input_.unpack();
  auto reserve = reserve_.unpack();
  auto running_mean = running_mean_.unpack();
  auto running_var = running_var_.unpack();
  auto save_mean = save_mean_.unpack();
  auto save_var = save_var_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto grad_out_ix = gen.range(1);
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto save_mean_ix = gen.range(1);
  auto save_var_ix = gen.range(1);
  auto reserve_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 6>{
    task_should_compute_output({ grad_out_ix }),
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ save_mean_ix }),
    task_should_compute_output({ save_var_ix }),
    task_should_compute_output({ reserve_ix }),
  };
  return BatchNormBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, eps, grad_out, input, reserve, running_mean, running_var, save_mean, save_var, update, weight);
}

void BatchNormBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(eps);
    args.collect(grad_out_, false);
    args.collect(input_, false);
    args.collect(reserve_, false);
    args.collect(running_mean_, false);
    args.collect(running_var_, false);
    args.collect(save_mean_, false);
    args.collect(save_var_, false);
    args.collect(update);
    args.collect(weight_, false);
}
variable_list BatchNormBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(eps);
  saved.before(grad_out_);
  saved.before(input_);
  saved.before(reserve_);
  saved.before(running_mean_);
  saved.before(running_var_);
  saved.before(save_mean_);
  saved.before(save_var_);
  saved.before(update);
  saved.before(weight_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 6>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<double>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), BatchNormBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto grad_out = grad_out_.unpack();
  auto input = input_.unpack();
  auto reserve = reserve_.unpack();
  auto running_mean = running_mean_.unpack();
  auto running_var = running_var_.unpack();
  auto save_mean = save_mean_.unpack();
  auto save_var = save_var_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto grad_out_ix = gen.range(1);
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto save_mean_ix = gen.range(1);
  auto save_var_ix = gen.range(1);
  auto reserve_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 6>{
    task_should_compute_output({ grad_out_ix }),
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ save_mean_ix }),
    task_should_compute_output({ save_var_ix }),
    task_should_compute_output({ reserve_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(eps);
  packed_args.pack(grad_out);
  packed_args.pack(input);
  packed_args.pack(reserve);
  packed_args.pack(running_mean);
  packed_args.pack(running_var);
  packed_args.pack(save_mean);
  packed_args.pack(save_var);
  packed_args.pack(update);
  packed_args.pack(weight);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(eps);
  saved.after(grad_out_);
  saved.after(input_);
  saved.after(reserve_);
  saved.after(running_mean_);
  saved.after(running_var_);
  saved.after(save_mean_);
  saved.after(save_var_);
  saved.after(update);
  saved.after(weight_);
  return output_result;
#endif
}

static variable_list NextafterBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*other*/1]) {
    auto grad_result = not_implemented("nextafter");
    copy_range(grad_inputs, other_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = not_implemented("nextafter");
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list NextafterBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();

  return NextafterBackward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list NextafterBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  return NextafterBackward0_apply_functional(std::move(grads), needs_input_grad);
}

void NextafterBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list NextafterBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), NextafterBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list NormBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, at::Scalar& p, Tensor& self, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (norm_backward(grad, self, p, result)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list NormBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto p = packed_args.unpack<at::Scalar>();
  auto self = packed_args.unpack<Tensor>();
  auto result = packed_args.unpack<Tensor>();
  return NormBackward0_apply_functional(variable_list(grads), needs_input_grad, p, self, result);
#endif
}

variable_list NormBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return NormBackward0_apply_functional(std::move(grads), needs_input_grad, p, self, result);
}

void NormBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(p);
    args.collect(self_, false);
    args.collect(result_, true);
}
variable_list NormBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(p);
  saved.before(self_);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), NormBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(p);
  packed_args.pack(self);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(p);
  saved.after(self_);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list NormBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<int64_t>& dim, bool& keepdim, ::std::optional<at::Scalar>& p, Tensor& self, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (norm_backward(grad, self, p, result, dim, keepdim)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list NormBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<std::vector<int64_t>>();
  auto keepdim = packed_args.unpack<bool>();
  auto p = packed_args.unpack<::std::optional<at::Scalar>>();
  auto self = packed_args.unpack<Tensor>();
  auto result = packed_args.unpack<Tensor>();
  return NormBackward1_apply_functional(variable_list(grads), needs_input_grad, dim, keepdim, p, self, result);
#endif
}

variable_list NormBackward1::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return NormBackward1_apply_functional(std::move(grads), needs_input_grad, dim, keepdim, p, self, result);
}

void NormBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(keepdim);
    args.collect(p);
    args.collect(self_, false);
    args.collect(result_, true);
}
variable_list NormBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(keepdim);
  saved.before(p);
  saved.before(self_);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<at::Scalar>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), NormBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(keepdim);
  packed_args.pack(p);
  packed_args.pack(self);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(keepdim);
  saved.after(p);
  saved.after(self_);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list NormBackward2_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, ::std::optional<at::Scalar>& p, Tensor& self, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (norm_backward(grad, self.to(grad.scalar_type()), p, result)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list NormBackward2_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto p = packed_args.unpack<::std::optional<at::Scalar>>();
  auto self = packed_args.unpack<Tensor>();
  auto result = packed_args.unpack<Tensor>();
  return NormBackward2_apply_functional(variable_list(grads), needs_input_grad, p, self, result);
#endif
}

variable_list NormBackward2::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return NormBackward2_apply_functional(std::move(grads), needs_input_grad, p, self, result);
}

void NormBackward2::compiled_args(CompiledNodeArgs& args) const {
    args.collect(p);
    args.collect(self_, false);
    args.collect(result_, true);
}
variable_list NormBackward2::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(p);
  saved.before(self_);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<at::Scalar>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), NormBackward2_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(p);
  packed_args.pack(self);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(p);
  saved.after(self_);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list NormBackward3_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<int64_t>& dim, bool& keepdim, ::std::optional<at::Scalar>& p, Tensor& self, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (norm_backward(grad, self.to(grad.scalar_type()), p, result, dim, keepdim)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list NormBackward3_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<std::vector<int64_t>>();
  auto keepdim = packed_args.unpack<bool>();
  auto p = packed_args.unpack<::std::optional<at::Scalar>>();
  auto self = packed_args.unpack<Tensor>();
  auto result = packed_args.unpack<Tensor>();
  return NormBackward3_apply_functional(variable_list(grads), needs_input_grad, dim, keepdim, p, self, result);
#endif
}

variable_list NormBackward3::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return NormBackward3_apply_functional(std::move(grads), needs_input_grad, dim, keepdim, p, self, result);
}

void NormBackward3::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(keepdim);
    args.collect(p);
    args.collect(self_, false);
    args.collect(result_, true);
}
variable_list NormBackward3::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(keepdim);
  saved.before(p);
  saved.before(self_);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<at::Scalar>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), NormBackward3_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(keepdim);
  packed_args.pack(p);
  packed_args.pack(self);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(keepdim);
  saved.after(p);
  saved.after(self_);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list LinalgVectorNormBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, c10::OptionalArray<int64_t>& dim, bool& keepdim, at::Scalar& ord, Tensor& self, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (linalg_vector_norm_backward(grad, self, ord, result, dim, keepdim)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list LinalgVectorNormBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<c10::OptionalArray<int64_t>>();
  auto keepdim = packed_args.unpack<bool>();
  auto ord = packed_args.unpack<at::Scalar>();
  auto self = packed_args.unpack<Tensor>();
  auto result = packed_args.unpack<Tensor>();
  return LinalgVectorNormBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, keepdim, ord, self, result);
#endif
}

variable_list LinalgVectorNormBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return LinalgVectorNormBackward0_apply_functional(std::move(grads), needs_input_grad, dim, keepdim, ord, self, result);
}

void LinalgVectorNormBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(keepdim);
    args.collect(ord);
    args.collect(self_, false);
    args.collect(result_, true);
}
variable_list LinalgVectorNormBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(keepdim);
  saved.before(ord);
  saved.before(self_);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::OptionalArray<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), LinalgVectorNormBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(keepdim);
  packed_args.pack(ord);
  packed_args.pack(self);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(keepdim);
  saved.after(ord);
  saved.after(self_);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list PdistBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, double& p, Tensor& self, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (_pdist_backward(grad, self, p, result)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list PdistBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto p = packed_args.unpack<double>();
  auto self = packed_args.unpack<Tensor>();
  auto result = packed_args.unpack<Tensor>();
  return PdistBackward0_apply_functional(variable_list(grads), needs_input_grad, p, self, result);
#endif
}

variable_list PdistBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return PdistBackward0_apply_functional(std::move(grads), needs_input_grad, p, self, result);
}

void PdistBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(p);
    args.collect(self_, false);
    args.collect(result_, true);
}
variable_list PdistBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(p);
  saved.before(self_);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<double>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), PdistBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(p);
  packed_args.pack(self);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(p);
  saved.after(self_);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list PdistBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto grad_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto pdist_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*grad*/0]) {
    auto grad_result = not_implemented("_pdist_backward");
    copy_range(grad_inputs, grad_ix, grad_result);
  }
  if (needs_input_grad[/*pdist*/2]) {
    auto grad_result = not_implemented("_pdist_backward");
    copy_range(grad_inputs, pdist_ix, grad_result);
  }
  if (needs_input_grad[/*self*/1]) {
    auto grad_result = not_implemented("_pdist_backward");
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list PdistBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();

  return PdistBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list PdistBackwardBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto grad_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto pdist_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ grad_ix }),
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ pdist_ix }),
  };
  return PdistBackwardBackward0_apply_functional(std::move(grads), needs_input_grad);
}

void PdistBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list PdistBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), PdistBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto grad_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto pdist_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ grad_ix }),
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ pdist_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list EuclideanDistBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& x1, Tensor& x2, Tensor& result)
{
  IndexRangeGenerator gen;
  auto x1_ix = gen.range(1);
  auto x2_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1]) {
  
    auto grad_result = _euclidean_dist_backward(grad, x1, x2, result);
      if (needs_input_grad[/*x1*/0]) {
        copy_range(grad_inputs, x1_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*x2*/1]) {
        copy_range(grad_inputs, x2_ix, std::get<1>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list EuclideanDistBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto x1 = packed_args.unpack<Tensor>();
  auto x2 = packed_args.unpack<Tensor>();
  auto result = packed_args.unpack<Tensor>();
  return EuclideanDistBackward0_apply_functional(variable_list(grads), needs_input_grad, x1, x2, result);
#endif
}

variable_list EuclideanDistBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto x1 = x1_.unpack();
  auto x2 = x2_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto x1_ix = gen.range(1);
  auto x2_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ x1_ix }),
    task_should_compute_output({ x2_ix }),
  };
  return EuclideanDistBackward0_apply_functional(std::move(grads), needs_input_grad, x1, x2, result);
}

void EuclideanDistBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(x1_, false);
    args.collect(x2_, false);
    args.collect(result_, true);
}
variable_list EuclideanDistBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(x1_);
  saved.before(x2_);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), EuclideanDistBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto x1 = x1_.unpack();
  auto x2 = x2_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto x1_ix = gen.range(1);
  auto x2_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ x1_ix }),
    task_should_compute_output({ x2_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(x1);
  packed_args.pack(x2);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(x1_);
  saved.after(x2_);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list CdistBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, double& p, Tensor& x1, Tensor& x2, Tensor& result)
{
  IndexRangeGenerator gen;
  auto x1_ix = gen.range(1);
  auto x2_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*x1*/0]) {
    auto grad_result = any_grad_defined ? (_cdist_backward(grad.contiguous(), x1, x2, p, result)) : Tensor();
    copy_range(grad_inputs, x1_ix, grad_result);
  }
  if (needs_input_grad[/*x2*/1]) {
    auto grad_result = any_grad_defined ? (_cdist_backward(grad.mT().contiguous(), x2, x1, p, result.mT().contiguous())) : Tensor();
    copy_range(grad_inputs, x2_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list CdistBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto p = packed_args.unpack<double>();
  auto x1 = packed_args.unpack<Tensor>();
  auto x2 = packed_args.unpack<Tensor>();
  auto result = packed_args.unpack<Tensor>();
  return CdistBackward0_apply_functional(variable_list(grads), needs_input_grad, p, x1, x2, result);
#endif
}

variable_list CdistBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto x1 = x1_.unpack();
  auto x2 = x2_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto x1_ix = gen.range(1);
  auto x2_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ x1_ix }),
    task_should_compute_output({ x2_ix }),
  };
  return CdistBackward0_apply_functional(std::move(grads), needs_input_grad, p, x1, x2, result);
}

void CdistBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(p);
    args.collect(x1_, false);
    args.collect(x2_, false);
    args.collect(result_, true);
}
variable_list CdistBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(p);
  saved.before(x1_);
  saved.before(x2_);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<double>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), CdistBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto x1 = x1_.unpack();
  auto x2 = x2_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto x1_ix = gen.range(1);
  auto x2_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ x1_ix }),
    task_should_compute_output({ x2_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(p);
  packed_args.pack(x1);
  packed_args.pack(x2);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(p);
  saved.after(x1_);
  saved.after(x2_);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list CdistBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,4> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto grad_ix = gen.range(1);
  auto x1_ix = gen.range(1);
  auto x2_ix = gen.range(1);
  auto cdist_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*cdist*/3]) {
    auto grad_result = not_implemented("_cdist_backward");
    copy_range(grad_inputs, cdist_ix, grad_result);
  }
  if (needs_input_grad[/*grad*/0]) {
    auto grad_result = not_implemented("_cdist_backward");
    copy_range(grad_inputs, grad_ix, grad_result);
  }
  if (needs_input_grad[/*x1*/1]) {
    auto grad_result = not_implemented("_cdist_backward");
    copy_range(grad_inputs, x1_ix, grad_result);
  }
  if (needs_input_grad[/*x2*/2]) {
    auto grad_result = not_implemented("_cdist_backward");
    copy_range(grad_inputs, x2_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list CdistBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 4>>();

  return CdistBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list CdistBackwardBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto grad_ix = gen.range(1);
  auto x1_ix = gen.range(1);
  auto x2_ix = gen.range(1);
  auto cdist_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 4>{
    task_should_compute_output({ grad_ix }),
    task_should_compute_output({ x1_ix }),
    task_should_compute_output({ x2_ix }),
    task_should_compute_output({ cdist_ix }),
  };
  return CdistBackwardBackward0_apply_functional(std::move(grads), needs_input_grad);
}

void CdistBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list CdistBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 4>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), CdistBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto grad_ix = gen.range(1);
  auto x1_ix = gen.range(1);
  auto x2_ix = gen.range(1);
  auto cdist_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 4>{
    task_should_compute_output({ grad_ix }),
    task_should_compute_output({ x1_ix }),
    task_should_compute_output({ x2_ix }),
    task_should_compute_output({ cdist_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list NormalBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (zeros_like(grad)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list NormalBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return NormalBackward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list NormalBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return NormalBackward0_apply_functional(std::move(grads), needs_input_grad);
}

void NormalBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list NormalBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), NormalBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list NormalBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<c10::SymInt>& mean_sym_sizes)
{
  IndexRangeGenerator gen;
  auto mean_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*mean*/0]) {
    auto grad_result = any_grad_defined ? (at::zeros_symint(mean_sym_sizes, grad.options())) : Tensor();
    copy_range(grad_inputs, mean_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list NormalBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto mean_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return NormalBackward1_apply_functional(variable_list(grads), needs_input_grad, mean_sym_sizes);
#endif
}

variable_list NormalBackward1::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto mean_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ mean_ix }),
  };
  return NormalBackward1_apply_functional(std::move(grads), needs_input_grad, mean_sym_sizes);
}

void NormalBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(mean_sym_sizes);
}
variable_list NormalBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(mean_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), NormalBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto mean_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ mean_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(mean_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(mean_sym_sizes);
  return output_result;
#endif
}

static variable_list NormalBackward2_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<c10::SymInt>& std_sym_sizes)
{
  IndexRangeGenerator gen;
  auto std_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*std*/0]) {
    auto grad_result = any_grad_defined ? (at::zeros_symint(std_sym_sizes, grad.options())) : Tensor();
    copy_range(grad_inputs, std_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list NormalBackward2_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto std_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return NormalBackward2_apply_functional(variable_list(grads), needs_input_grad, std_sym_sizes);
#endif
}

variable_list NormalBackward2::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto std_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ std_ix }),
  };
  return NormalBackward2_apply_functional(std::move(grads), needs_input_grad, std_sym_sizes);
}

void NormalBackward2::compiled_args(CompiledNodeArgs& args) const {
    args.collect(std_sym_sizes);
}
variable_list NormalBackward2::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(std_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), NormalBackward2_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto std_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ std_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(std_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(std_sym_sizes);
  return output_result;
#endif
}

static variable_list NormalBackward3_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, std::vector<c10::SymInt>& mean_sym_sizes, std::vector<c10::SymInt>& std_sym_sizes)
{
  IndexRangeGenerator gen;
  auto mean_ix = gen.range(1);
  auto std_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*mean*/0]) {
    auto grad_result = any_grad_defined ? (at::zeros_symint(mean_sym_sizes, grad.options())) : Tensor();
    copy_range(grad_inputs, mean_ix, grad_result);
  }
  if (needs_input_grad[/*std*/1]) {
    auto grad_result = any_grad_defined ? (at::zeros_symint(std_sym_sizes, grad.options())) : Tensor();
    copy_range(grad_inputs, std_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list NormalBackward3_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto mean_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  auto std_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return NormalBackward3_apply_functional(variable_list(grads), needs_input_grad, mean_sym_sizes, std_sym_sizes);
#endif
}

variable_list NormalBackward3::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto mean_ix = gen.range(1);
  auto std_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ mean_ix }),
    task_should_compute_output({ std_ix }),
  };
  return NormalBackward3_apply_functional(std::move(grads), needs_input_grad, mean_sym_sizes, std_sym_sizes);
}

void NormalBackward3::compiled_args(CompiledNodeArgs& args) const {
    args.collect(mean_sym_sizes);
    args.collect(std_sym_sizes);
}
variable_list NormalBackward3::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(mean_sym_sizes);
  saved.before(std_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), NormalBackward3_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto mean_ix = gen.range(1);
  auto std_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ mean_ix }),
    task_should_compute_output({ std_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(mean_sym_sizes);
  packed_args.pack(std_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(mean_sym_sizes);
  saved.after(std_sym_sizes);
  return output_result;
#endif
}

static variable_list LinalgHouseholderProductBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& input, Tensor& tau, Tensor& result)
{
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto tau_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1]) {
  
    auto grad_result = householder_product_backward(grad, result, input, tau);
      if (needs_input_grad[/*input*/0]) {
        copy_range(grad_inputs, input_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*tau*/1]) {
        copy_range(grad_inputs, tau_ix, std::get<1>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list LinalgHouseholderProductBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto input = packed_args.unpack<Tensor>();
  auto tau = packed_args.unpack<Tensor>();
  auto result = packed_args.unpack<Tensor>();
  return LinalgHouseholderProductBackward0_apply_functional(variable_list(grads), needs_input_grad, input, tau, result);
#endif
}

variable_list LinalgHouseholderProductBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto input = input_.unpack();
  auto tau = tau_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto tau_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ tau_ix }),
  };
  return LinalgHouseholderProductBackward0_apply_functional(std::move(grads), needs_input_grad, input, tau, result);
}

void LinalgHouseholderProductBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(input_, false);
    args.collect(tau_, false);
    args.collect(result_, true);
}
variable_list LinalgHouseholderProductBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(input_);
  saved.before(tau_);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), LinalgHouseholderProductBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto input = input_.unpack();
  auto tau = tau_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto tau_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ tau_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(input);
  packed_args.pack(tau);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(input_);
  saved.after(tau_);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list OrmqrBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, Tensor& input2, Tensor& input3, bool& left, Tensor& self, bool& transpose, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto input2_ix = gen.range(1);
  auto input3_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1] || needs_input_grad[2]) {
      auto grad_input_mask = std::array<bool, 3>{
        needs_input_grad[0],
        needs_input_grad[1],
        needs_input_grad[2],
      };
    auto grad_result = ormqr_backward(grad, result, self, input2, input3, left, transpose, grad_input_mask);
      if (needs_input_grad[/*self*/0]) {
        copy_range(grad_inputs, self_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*input2*/1]) {
        copy_range(grad_inputs, input2_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*input3*/2]) {
        copy_range(grad_inputs, input3_ix, std::get<2>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list OrmqrBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto input2 = packed_args.unpack<Tensor>();
  auto input3 = packed_args.unpack<Tensor>();
  auto left = packed_args.unpack<bool>();
  auto self = packed_args.unpack<Tensor>();
  auto transpose = packed_args.unpack<bool>();
  auto result = packed_args.unpack<Tensor>();
  return OrmqrBackward0_apply_functional(variable_list(grads), needs_input_grad, input2, input3, left, self, transpose, result);
#endif
}

variable_list OrmqrBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto input2 = input2_.unpack();
  auto input3 = input3_.unpack();
  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto input2_ix = gen.range(1);
  auto input3_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ input2_ix }),
    task_should_compute_output({ input3_ix }),
  };
  return OrmqrBackward0_apply_functional(std::move(grads), needs_input_grad, input2, input3, left, self, transpose, result);
}

void OrmqrBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(input2_, false);
    args.collect(input3_, false);
    args.collect(left);
    args.collect(self_, false);
    args.collect(transpose);
    args.collect(result_, true);
}
variable_list OrmqrBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(input2_);
  saved.before(input3_);
  saved.before(left);
  saved.before(self_);
  saved.before(transpose);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), OrmqrBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto input2 = input2_.unpack();
  auto input3 = input3_.unpack();
  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto input2_ix = gen.range(1);
  auto input3_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ input2_ix }),
    task_should_compute_output({ input3_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(input2);
  packed_args.pack(input3);
  packed_args.pack(left);
  packed_args.pack(self);
  packed_args.pack(transpose);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(input2_);
  saved.after(input3_);
  saved.after(left);
  saved.after(self_);
  saved.after(transpose);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list PermuteBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<int64_t>& dims)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (permute_backwards(grad, dims)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list PermuteBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dims = packed_args.unpack<std::vector<int64_t>>();
  return PermuteBackward0_apply_functional(variable_list(grads), needs_input_grad, dims);
#endif
}

variable_list PermuteBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return PermuteBackward0_apply_functional(std::move(grads), needs_input_grad, dims);
}

void PermuteBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dims);
}
variable_list PermuteBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dims);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), PermuteBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dims);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dims);
  return output_result;
#endif
}

static variable_list PoissonBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, torch::autograd::generated::TypeAndSize& self_info)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (self_info.zeros()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list PoissonBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_info = packed_args.unpack<torch::autograd::generated::TypeAndSize>();
  return PoissonBackward0_apply_functional(variable_list(grads), needs_input_grad, self_info);
#endif
}

variable_list PoissonBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return PoissonBackward0_apply_functional(std::move(grads), needs_input_grad, self_info);
}

void PoissonBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_info);
}
variable_list PoissonBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_info);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::autograd::generated::TypeAndSize>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), PoissonBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_info);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_info);
  return output_result;
#endif
}

static variable_list PowBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, at::Scalar& exponent, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (pow_backward(grad, self, exponent)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list PowBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto exponent = packed_args.unpack<at::Scalar>();
  auto self = packed_args.unpack<Tensor>();
  return PowBackward0_apply_functional(variable_list(grads), needs_input_grad, exponent, self);
#endif
}

variable_list PowBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return PowBackward0_apply_functional(std::move(grads), needs_input_grad, exponent, self);
}

void PowBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(exponent);
    args.collect(self_, false);
}
variable_list PowBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(exponent);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), PowBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(exponent);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(exponent);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list PowBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& exponent, Tensor& self, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto exponent_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*exponent*/1]) {
    auto grad_result = any_grad_defined ? (pow_backward_exponent(grad, self, exponent, result)) : Tensor();
    copy_range(grad_inputs, exponent_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (pow_backward_self(grad, self, exponent)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list PowBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto exponent = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<Tensor>();
  auto result = packed_args.unpack<Tensor>();
  return PowBackward1_apply_functional(variable_list(grads), needs_input_grad, exponent, self, result);
#endif
}

variable_list PowBackward1::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto exponent = exponent_.unpack();
  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto exponent_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ exponent_ix }),
  };
  return PowBackward1_apply_functional(std::move(grads), needs_input_grad, exponent, self, result);
}

void PowBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(exponent_, false);
    args.collect(self_, false);
    args.collect(result_, true);
}
variable_list PowBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(exponent_);
  saved.before(self_);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), PowBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto exponent = exponent_.unpack();
  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto exponent_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ exponent_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(exponent);
  packed_args.pack(self);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(exponent_);
  saved.after(self_);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list PowBackward2_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& exponent, at::Scalar& self, Tensor& result)
{
  IndexRangeGenerator gen;
  auto exponent_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*exponent*/0]) {
    auto grad_result = any_grad_defined ? (pow_backward_exponent(grad, self, exponent, result)) : Tensor();
    copy_range(grad_inputs, exponent_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list PowBackward2_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto exponent = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<at::Scalar>();
  auto result = packed_args.unpack<Tensor>();
  return PowBackward2_apply_functional(variable_list(grads), needs_input_grad, exponent, self, result);
#endif
}

variable_list PowBackward2::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto exponent = exponent_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto exponent_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ exponent_ix }),
  };
  return PowBackward2_apply_functional(std::move(grads), needs_input_grad, exponent, self, result);
}

void PowBackward2::compiled_args(CompiledNodeArgs& args) const {
    args.collect(exponent_, false);
    args.collect(self);
    args.collect(result_, true);
}
variable_list PowBackward2::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(exponent_);
  saved.before(self);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), PowBackward2_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto exponent = exponent_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto exponent_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ exponent_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(exponent);
  packed_args.pack(self);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(exponent_);
  saved.after(self);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list ProdBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (prod_backward(grad, self.to(grad.scalar_type()), result)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ProdBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  auto result = packed_args.unpack<Tensor>();
  return ProdBackward0_apply_functional(variable_list(grads), needs_input_grad, self, result);
#endif
}

variable_list ProdBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ProdBackward0_apply_functional(std::move(grads), needs_input_grad, self, result);
}

void ProdBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
    args.collect(result_, true);
}
variable_list ProdBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ProdBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list ProdBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim, bool& keepdim, Tensor& self, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (prod_backward(grad, self.to(grad.scalar_type()), result, dim, keepdim)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ProdBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  auto keepdim = packed_args.unpack<bool>();
  auto self = packed_args.unpack<Tensor>();
  auto result = packed_args.unpack<Tensor>();
  return ProdBackward1_apply_functional(variable_list(grads), needs_input_grad, dim, keepdim, self, result);
#endif
}

variable_list ProdBackward1::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ProdBackward1_apply_functional(std::move(grads), needs_input_grad, dim, keepdim, self, result);
}

void ProdBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(keepdim);
    args.collect(self_, false);
    args.collect(result_, true);
}
variable_list ProdBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(keepdim);
  saved.before(self_);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ProdBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(keepdim);
  packed_args.pack(self);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(keepdim);
  saved.after(self_);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list PutBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, bool& accumulate, Tensor& index, Tensor& source, torch::autograd::generated::TypeAndSize& source_info)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto source_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (accumulate ? grad : grad.put(index, source_info.zeros(), false)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  if (needs_input_grad[/*source*/1]) {
    auto grad_result = any_grad_defined ? (grad.take(index).reshape_as(source)) : Tensor();
    copy_range(grad_inputs, source_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list PutBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto accumulate = packed_args.unpack<bool>();
  auto index = packed_args.unpack<Tensor>();
  auto source = packed_args.unpack<Tensor>();
  auto source_info = packed_args.unpack<torch::autograd::generated::TypeAndSize>();
  return PutBackward0_apply_functional(variable_list(grads), needs_input_grad, accumulate, index, source, source_info);
#endif
}

variable_list PutBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto index = index_.unpack();
  auto source = source_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto source_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ source_ix }),
  };
  return PutBackward0_apply_functional(std::move(grads), needs_input_grad, accumulate, index, source, source_info);
}

void PutBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(accumulate);
    args.collect(index_, false);
    args.collect(source_, false);
    args.collect(source_info);
}
variable_list PutBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(accumulate);
  saved.before(index_);
  saved.before(source_);
  saved.before(source_info);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::autograd::generated::TypeAndSize>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), PutBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto index = index_.unpack();
  auto source = source_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto source_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ source_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(accumulate);
  packed_args.pack(index);
  packed_args.pack(source);
  packed_args.pack(source_info);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(accumulate);
  saved.after(index_);
  saved.after(source_);
  saved.after(source_info);
  return output_result;
#endif
}

static variable_list LinalgQrBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::string& mode, Tensor& Q, Tensor& R)
{
  IndexRangeGenerator gen;
  auto A_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad_Q = grads[0];
  const auto& grad_R = grads[1];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*A*/0]) {
    auto grad_result = any_grad_defined ? (linalg_qr_backward(grad_Q, grad_R, Q, R, mode)) : Tensor();
    copy_range(grad_inputs, A_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list LinalgQrBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto mode = packed_args.unpack<std::string>();
  auto Q = packed_args.unpack<Tensor>();
  auto R = packed_args.unpack<Tensor>();
  return LinalgQrBackward0_apply_functional(variable_list(grads), needs_input_grad, mode, Q, R);
#endif
}

variable_list LinalgQrBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto Q = Q_.unpack(shared_from_this());
  auto R = R_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto A_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ A_ix }),
  };
  return LinalgQrBackward0_apply_functional(std::move(grads), needs_input_grad, mode, Q, R);
}

void LinalgQrBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(mode);
    args.collect(Q_, true);
    args.collect(R_, true);
}
variable_list LinalgQrBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(mode);
  saved.before(Q_);
  saved.before(R_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::string>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), LinalgQrBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto Q = Q_.unpack(shared_from_this());
  auto R = R_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto A_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ A_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(mode);
  packed_args.pack(Q);
  packed_args.pack(R);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(mode);
  saved.after(Q_);
  saved.after(R_);
  return output_result;
#endif
}

static variable_list Rad2DegBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (rad2deg_backward(grad)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list Rad2DegBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return Rad2DegBackward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list Rad2DegBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return Rad2DegBackward0_apply_functional(std::move(grads), needs_input_grad);
}

void Rad2DegBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list Rad2DegBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), Rad2DegBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list RandomBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (zeros_like(grad)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list RandomBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return RandomBackward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list RandomBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return RandomBackward0_apply_functional(std::move(grads), needs_input_grad);
}

void RandomBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list RandomBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), RandomBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list RandomBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (zeros_like(grad)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list RandomBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return RandomBackward1_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list RandomBackward1::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return RandomBackward1_apply_functional(std::move(grads), needs_input_grad);
}

void RandomBackward1::compiled_args(CompiledNodeArgs& args) const {

}
variable_list RandomBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), RandomBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list RandomBackward2_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (zeros_like(grad)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list RandomBackward2_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return RandomBackward2_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list RandomBackward2::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return RandomBackward2_apply_functional(std::move(grads), needs_input_grad);
}

void RandomBackward2::compiled_args(CompiledNodeArgs& args) const {

}
variable_list RandomBackward2::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), RandomBackward2_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list ReciprocalBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (-grad * (result * result).conj()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ReciprocalBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto result = packed_args.unpack<Tensor>();
  return ReciprocalBackward0_apply_functional(variable_list(grads), needs_input_grad, result);
#endif
}

variable_list ReciprocalBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ReciprocalBackward0_apply_functional(std::move(grads), needs_input_grad, result);
}

void ReciprocalBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(result_, true);
}
variable_list ReciprocalBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ReciprocalBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(result_);
  return output_result;
#endif
}

static variable_list RemainderBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list RemainderBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return RemainderBackward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list RemainderBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return RemainderBackward0_apply_functional(std::move(grads), needs_input_grad);
}

void RemainderBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list RemainderBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), RemainderBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list RemainderBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& other, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*other*/1]) {
    auto grad_result = any_grad_defined ? (-grad * self.div(other, /*rounding_mode=*/"floor")) : Tensor();
    copy_range(grad_inputs, other_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list RemainderBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto other = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<Tensor>();
  return RemainderBackward1_apply_functional(variable_list(grads), needs_input_grad, other, self);
#endif
}

variable_list RemainderBackward1::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto other = other_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  return RemainderBackward1_apply_functional(std::move(grads), needs_input_grad, other, self);
}

void RemainderBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(other_, false);
    args.collect(self_, false);
}
variable_list RemainderBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(other_);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), RemainderBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto other = other_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(other);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(other_);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list RenormBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim, at::Scalar& maxnorm, at::Scalar& p, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (renorm_backward(grad, self, p, dim, maxnorm)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list RenormBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  auto maxnorm = packed_args.unpack<at::Scalar>();
  auto p = packed_args.unpack<at::Scalar>();
  auto self = packed_args.unpack<Tensor>();
  return RenormBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, maxnorm, p, self);
#endif
}

variable_list RenormBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return RenormBackward0_apply_functional(std::move(grads), needs_input_grad, dim, maxnorm, p, self);
}

void RenormBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(maxnorm);
    args.collect(p);
    args.collect(self_, false);
}
variable_list RenormBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(maxnorm);
  saved.before(p);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), RenormBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(maxnorm);
  packed_args.pack(p);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(maxnorm);
  saved.after(p);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list RepeatBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<c10::SymInt>& repeats, std::vector<c10::SymInt>& self_sym_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (repeat_backward(grad, repeats, self_sym_sizes)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list RepeatBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto repeats = packed_args.unpack<std::vector<c10::SymInt>>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return RepeatBackward0_apply_functional(variable_list(grads), needs_input_grad, repeats, self_sym_sizes);
#endif
}

variable_list RepeatBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return RepeatBackward0_apply_functional(std::move(grads), needs_input_grad, repeats, self_sym_sizes);
}

void RepeatBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(repeats);
    args.collect(self_sym_sizes);
}
variable_list RepeatBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(repeats);
  saved.before(self_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), RepeatBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(repeats);
  packed_args.pack(self_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(repeats);
  saved.after(self_sym_sizes);
  return output_result;
#endif
}

static variable_list SpecialEntrBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad * (-(1 + self.log()))) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SpecialEntrBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  return SpecialEntrBackward0_apply_functional(variable_list(grads), needs_input_grad, self);
#endif
}

variable_list SpecialEntrBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SpecialEntrBackward0_apply_functional(std::move(grads), needs_input_grad, self);
}

void SpecialEntrBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list SpecialEntrBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SpecialEntrBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list SpecialNdtriBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad * std::sqrt(2 * M_PI) * (result.square() / 2).exp()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SpecialNdtriBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto result = packed_args.unpack<Tensor>();
  return SpecialNdtriBackward0_apply_functional(variable_list(grads), needs_input_grad, result);
#endif
}

variable_list SpecialNdtriBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SpecialNdtriBackward0_apply_functional(std::move(grads), needs_input_grad, result);
}

void SpecialNdtriBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(result_, true);
}
variable_list SpecialNdtriBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SpecialNdtriBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(result_);
  return output_result;
#endif
}

static variable_list SpecialLogNdtrBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad / std::sqrt(2 * M_PI) * (result + self.pow(2) / 2).neg().exp()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SpecialLogNdtrBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  auto result = packed_args.unpack<Tensor>();
  return SpecialLogNdtrBackward0_apply_functional(variable_list(grads), needs_input_grad, self, result);
#endif
}

variable_list SpecialLogNdtrBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SpecialLogNdtrBackward0_apply_functional(std::move(grads), needs_input_grad, self, result);
}

void SpecialLogNdtrBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
    args.collect(result_, true);
}
variable_list SpecialLogNdtrBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SpecialLogNdtrBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list ReshapeAliasBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<c10::SymInt>& self_sym_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.reshape_symint(self_sym_sizes)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ReshapeAliasBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return ReshapeAliasBackward0_apply_functional(variable_list(grads), needs_input_grad, self_sym_sizes);
#endif
}

variable_list ReshapeAliasBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ReshapeAliasBackward0_apply_functional(std::move(grads), needs_input_grad, self_sym_sizes);
}

void ReshapeAliasBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_sym_sizes);
}
variable_list ReshapeAliasBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ReshapeAliasBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_sym_sizes);
  return output_result;
#endif
}

static variable_list RoundBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (zeros_like(grad)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list RoundBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return RoundBackward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list RoundBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return RoundBackward0_apply_functional(std::move(grads), needs_input_grad);
}

void RoundBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list RoundBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), RoundBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list RoundBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (zeros_like(grad)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list RoundBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return RoundBackward1_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list RoundBackward1::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return RoundBackward1_apply_functional(std::move(grads), needs_input_grad);
}

void RoundBackward1::compiled_args(CompiledNodeArgs& args) const {

}
variable_list RoundBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), RoundBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list RsqrtBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (-0.5 * grad * result.pow(3).conj()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list RsqrtBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto result = packed_args.unpack<Tensor>();
  return RsqrtBackward0_apply_functional(variable_list(grads), needs_input_grad, result);
#endif
}

variable_list RsqrtBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return RsqrtBackward0_apply_functional(std::move(grads), needs_input_grad, result);
}

void RsqrtBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(result_, true);
}
variable_list RsqrtBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), RsqrtBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(result_);
  return output_result;
#endif
}

static variable_list ScatterBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, int64_t& dim, Tensor& index)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto src_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.scatter(dim, index, 0)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  if (needs_input_grad[/*src*/1]) {
    auto grad_result = any_grad_defined ? (grad.gather(dim, index)) : Tensor();
    copy_range(grad_inputs, src_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ScatterBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto dim = packed_args.unpack<int64_t>();
  auto index = packed_args.unpack<Tensor>();
  return ScatterBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, index);
#endif
}

variable_list ScatterBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto index = index_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto src_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ src_ix }),
  };
  return ScatterBackward0_apply_functional(std::move(grads), needs_input_grad, dim, index);
}

void ScatterBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(index_, false);
}
variable_list ScatterBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(index_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ScatterBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto index = index_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto src_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ src_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(index);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(index_);
  return output_result;
#endif
}

static variable_list ScatterBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim, Tensor& index)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.scatter(dim, index, 0)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ScatterBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  auto index = packed_args.unpack<Tensor>();
  return ScatterBackward1_apply_functional(variable_list(grads), needs_input_grad, dim, index);
#endif
}

variable_list ScatterBackward1::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto index = index_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ScatterBackward1_apply_functional(std::move(grads), needs_input_grad, dim, index);
}

void ScatterBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(index_, false);
}
variable_list ScatterBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(index_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ScatterBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto index = index_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(index);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(index_);
  return output_result;
#endif
}

static variable_list ScatterAddBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, int64_t& dim, Tensor& index)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto src_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  if (needs_input_grad[/*src*/1]) {
    auto grad_result = any_grad_defined ? (grad.gather(dim, index)) : Tensor();
    copy_range(grad_inputs, src_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ScatterAddBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto dim = packed_args.unpack<int64_t>();
  auto index = packed_args.unpack<Tensor>();
  return ScatterAddBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, index);
#endif
}

variable_list ScatterAddBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto index = index_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto src_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ src_ix }),
  };
  return ScatterAddBackward0_apply_functional(std::move(grads), needs_input_grad, dim, index);
}

void ScatterAddBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(index_, false);
}
variable_list ScatterAddBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(index_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ScatterAddBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto index = index_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto src_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ src_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(index);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(index_);
  return output_result;
#endif
}

static variable_list SelectBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim, c10::SymInt& index, std::vector<c10::SymInt>& self_sym_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (select_backward_symint(grad, self_sym_sizes, dim, index)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SelectBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  auto index = packed_args.unpack<c10::SymInt>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return SelectBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, index, self_sym_sizes);
#endif
}

variable_list SelectBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SelectBackward0_apply_functional(std::move(grads), needs_input_grad, dim, index, self_sym_sizes);
}

void SelectBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(index);
    args.collect(self_sym_sizes);
}
variable_list SelectBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(index);
  saved.before(self_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SelectBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(index);
  packed_args.pack(self_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(index);
  saved.after(self_sym_sizes);
  return output_result;
#endif
}

static variable_list SelectBackwardAutogradNestedTensor0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim, c10::SymInt& index, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (_nested_select_backward_symint(grad, self, dim, index)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SelectBackwardAutogradNestedTensor0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  auto index = packed_args.unpack<c10::SymInt>();
  auto self = packed_args.unpack<Tensor>();
  return SelectBackwardAutogradNestedTensor0_apply_functional(variable_list(grads), needs_input_grad, dim, index, self);
#endif
}

variable_list SelectBackwardAutogradNestedTensor0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SelectBackwardAutogradNestedTensor0_apply_functional(std::move(grads), needs_input_grad, dim, index, self);
}

void SelectBackwardAutogradNestedTensor0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(index);
    args.collect(self_, false);
}
variable_list SelectBackwardAutogradNestedTensor0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(index);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SelectBackwardAutogradNestedTensor0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(index);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(index);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list SelectBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim, c10::SymInt& index)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (grad.select_symint(dim, index)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SelectBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  auto index = packed_args.unpack<c10::SymInt>();
  return SelectBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, index);
#endif
}

variable_list SelectBackwardBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ grad_output_ix }),
  };
  return SelectBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, dim, index);
}

void SelectBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(index);
}
variable_list SelectBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(index);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SelectBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ grad_output_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(index);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(index);
  return output_result;
#endif
}

static variable_list SigmoidBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (sigmoid_backward(grad, result)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SigmoidBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto result = packed_args.unpack<Tensor>();
  return SigmoidBackward0_apply_functional(variable_list(grads), needs_input_grad, result);
#endif
}

variable_list SigmoidBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SigmoidBackward0_apply_functional(std::move(grads), needs_input_grad, result);
}

void SigmoidBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(result_, true);
}
variable_list SigmoidBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SigmoidBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(result_);
  return output_result;
#endif
}

static variable_list LogitBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, ::std::optional<double>& eps, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (GradMode::is_enabled() ? infinitely_differentiable_logit_backward(grad, self, eps) : logit_backward(grad, self, eps)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list LogitBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto eps = packed_args.unpack<::std::optional<double>>();
  auto self = packed_args.unpack<Tensor>();
  return LogitBackward0_apply_functional(variable_list(grads), needs_input_grad, eps, self);
#endif
}

variable_list LogitBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return LogitBackward0_apply_functional(std::move(grads), needs_input_grad, eps, self);
}

void LogitBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(eps);
    args.collect(self_, false);
}
variable_list LogitBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(eps);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), LogitBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(eps);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(eps);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list SignBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (zeros_like(grad)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SignBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return SignBackward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list SignBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SignBackward0_apply_functional(std::move(grads), needs_input_grad);
}

void SignBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list SignBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SignBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list SgnBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (sgn_backward(self, grad, result)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SgnBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  auto result = packed_args.unpack<Tensor>();
  return SgnBackward0_apply_functional(variable_list(grads), needs_input_grad, self, result);
#endif
}

variable_list SgnBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SgnBackward0_apply_functional(std::move(grads), needs_input_grad, self, result);
}

void SgnBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
    args.collect(result_, true);
}
variable_list SgnBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SgnBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list SinBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad * self.cos().conj()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SinBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  return SinBackward0_apply_functional(variable_list(grads), needs_input_grad, self);
#endif
}

variable_list SinBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SinBackward0_apply_functional(std::move(grads), needs_input_grad, self);
}

void SinBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list SinBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SinBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list SincBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (sinc_backward(grad, self)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SincBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  return SincBackward0_apply_functional(variable_list(grads), needs_input_grad, self);
#endif
}

variable_list SincBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SincBackward0_apply_functional(std::move(grads), needs_input_grad, self);
}

void SincBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list SincBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SincBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list SinhBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad * self.cosh().conj()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SinhBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  return SinhBackward0_apply_functional(variable_list(grads), needs_input_grad, self);
#endif
}

variable_list SinhBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SinhBackward0_apply_functional(std::move(grads), needs_input_grad, self);
}

void SinhBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list SinhBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SinhBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list SliceBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim, ::std::optional<c10::SymInt>& end, std::vector<c10::SymInt>& self_sym_sizes, ::std::optional<c10::SymInt>& start, c10::SymInt& step)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (slice_backward_wrapper(grad, self_sym_sizes, dim, start, end, step)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SliceBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  auto end = packed_args.unpack<::std::optional<c10::SymInt>>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  auto start = packed_args.unpack<::std::optional<c10::SymInt>>();
  auto step = packed_args.unpack<c10::SymInt>();
  return SliceBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, end, self_sym_sizes, start, step);
#endif
}

variable_list SliceBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SliceBackward0_apply_functional(std::move(grads), needs_input_grad, dim, end, self_sym_sizes, start, step);
}

void SliceBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(end);
    args.collect(self_sym_sizes);
    args.collect(start);
    args.collect(step);
}
variable_list SliceBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(end);
  saved.before(self_sym_sizes);
  saved.before(start);
  saved.before(step);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SliceBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(end);
  packed_args.pack(self_sym_sizes);
  packed_args.pack(start);
  packed_args.pack(step);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(end);
  saved.after(self_sym_sizes);
  saved.after(start);
  saved.after(step);
  return output_result;
#endif
}

static variable_list SliceBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim, c10::SymInt& end, c10::SymInt& start, c10::SymInt& step)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (grad.slice_symint(dim, start, end, step)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SliceBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  auto end = packed_args.unpack<c10::SymInt>();
  auto start = packed_args.unpack<c10::SymInt>();
  auto step = packed_args.unpack<c10::SymInt>();
  return SliceBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, end, start, step);
#endif
}

variable_list SliceBackwardBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ grad_output_ix }),
  };
  return SliceBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, dim, end, start, step);
}

void SliceBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(end);
    args.collect(start);
    args.collect(step);
}
variable_list SliceBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(end);
  saved.before(start);
  saved.before(step);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SliceBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ grad_output_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(end);
  packed_args.pack(start);
  packed_args.pack(step);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(end);
  saved.after(start);
  saved.after(step);
  return output_result;
#endif
}

static variable_list SliceInverseBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, int64_t& dim, ::std::optional<c10::SymInt>& end, torch::autograd::generated::TypeAndSize& self_info, ::std::optional<c10::SymInt>& start, c10::SymInt& step)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto src_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.slice_symint(dim, start, end, step)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  if (needs_input_grad[/*src*/1]) {
    auto grad_result = any_grad_defined ? (slice_scatter_symint(grad, self_info.zeros(), dim, start, end, step)) : Tensor();
    copy_range(grad_inputs, src_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SliceInverseBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto dim = packed_args.unpack<int64_t>();
  auto end = packed_args.unpack<::std::optional<c10::SymInt>>();
  auto self_info = packed_args.unpack<torch::autograd::generated::TypeAndSize>();
  auto start = packed_args.unpack<::std::optional<c10::SymInt>>();
  auto step = packed_args.unpack<c10::SymInt>();
  return SliceInverseBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, end, self_info, start, step);
#endif
}

variable_list SliceInverseBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto src_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ src_ix }),
  };
  return SliceInverseBackward0_apply_functional(std::move(grads), needs_input_grad, dim, end, self_info, start, step);
}

void SliceInverseBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(end);
    args.collect(self_info);
    args.collect(start);
    args.collect(step);
}
variable_list SliceInverseBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(end);
  saved.before(self_info);
  saved.before(start);
  saved.before(step);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::autograd::generated::TypeAndSize>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SliceInverseBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto src_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ src_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(end);
  packed_args.pack(self_info);
  packed_args.pack(start);
  packed_args.pack(step);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(end);
  saved.after(self_info);
  saved.after(start);
  saved.after(step);
  return output_result;
#endif
}

static variable_list SliceScatterBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, int64_t& dim, ::std::optional<c10::SymInt>& end, torch::autograd::generated::TypeAndSize& src_info, ::std::optional<c10::SymInt>& start, c10::SymInt& step)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto src_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (slice_scatter_symint(grad, src_info.zeros(), dim, start, end, step)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  if (needs_input_grad[/*src*/1]) {
    auto grad_result = any_grad_defined ? (grad.slice_symint(dim, start, end, step)) : Tensor();
    copy_range(grad_inputs, src_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SliceScatterBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto dim = packed_args.unpack<int64_t>();
  auto end = packed_args.unpack<::std::optional<c10::SymInt>>();
  auto src_info = packed_args.unpack<torch::autograd::generated::TypeAndSize>();
  auto start = packed_args.unpack<::std::optional<c10::SymInt>>();
  auto step = packed_args.unpack<c10::SymInt>();
  return SliceScatterBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, end, src_info, start, step);
#endif
}

variable_list SliceScatterBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto src_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ src_ix }),
  };
  return SliceScatterBackward0_apply_functional(std::move(grads), needs_input_grad, dim, end, src_info, start, step);
}

void SliceScatterBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(end);
    args.collect(src_info);
    args.collect(start);
    args.collect(step);
}
variable_list SliceScatterBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(end);
  saved.before(src_info);
  saved.before(start);
  saved.before(step);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::autograd::generated::TypeAndSize>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SliceScatterBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto src_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ src_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(end);
  packed_args.pack(src_info);
  packed_args.pack(start);
  packed_args.pack(step);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(end);
  saved.after(src_info);
  saved.after(start);
  saved.after(step);
  return output_result;
#endif
}

static variable_list SelectScatterBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, int64_t& dim, c10::SymInt& index, torch::autograd::generated::TypeAndSize& src_info)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto src_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (select_scatter_symint(grad, src_info.zeros(), dim, index)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  if (needs_input_grad[/*src*/1]) {
    auto grad_result = any_grad_defined ? (grad.select_symint(dim, index)) : Tensor();
    copy_range(grad_inputs, src_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SelectScatterBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto dim = packed_args.unpack<int64_t>();
  auto index = packed_args.unpack<c10::SymInt>();
  auto src_info = packed_args.unpack<torch::autograd::generated::TypeAndSize>();
  return SelectScatterBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, index, src_info);
#endif
}

variable_list SelectScatterBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto src_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ src_ix }),
  };
  return SelectScatterBackward0_apply_functional(std::move(grads), needs_input_grad, dim, index, src_info);
}

void SelectScatterBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(index);
    args.collect(src_info);
}
variable_list SelectScatterBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(index);
  saved.before(src_info);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::autograd::generated::TypeAndSize>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SelectScatterBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto src_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ src_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(index);
  packed_args.pack(src_info);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(index);
  saved.after(src_info);
  return output_result;
#endif
}

static variable_list DiagonalScatterBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, int64_t& dim1, int64_t& dim2, int64_t& offset, torch::autograd::generated::TypeAndSize& src_info)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto src_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (diagonal_scatter(grad, src_info.zeros(), offset, dim1, dim2)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  if (needs_input_grad[/*src*/1]) {
    auto grad_result = any_grad_defined ? (grad.diagonal(offset, dim1, dim2)) : Tensor();
    copy_range(grad_inputs, src_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list DiagonalScatterBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto dim1 = packed_args.unpack<int64_t>();
  auto dim2 = packed_args.unpack<int64_t>();
  auto offset = packed_args.unpack<int64_t>();
  auto src_info = packed_args.unpack<torch::autograd::generated::TypeAndSize>();
  return DiagonalScatterBackward0_apply_functional(variable_list(grads), needs_input_grad, dim1, dim2, offset, src_info);
#endif
}

variable_list DiagonalScatterBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto src_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ src_ix }),
  };
  return DiagonalScatterBackward0_apply_functional(std::move(grads), needs_input_grad, dim1, dim2, offset, src_info);
}

void DiagonalScatterBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim1);
    args.collect(dim2);
    args.collect(offset);
    args.collect(src_info);
}
variable_list DiagonalScatterBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim1);
  saved.before(dim2);
  saved.before(offset);
  saved.before(src_info);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::autograd::generated::TypeAndSize>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), DiagonalScatterBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto src_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ src_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim1);
  packed_args.pack(dim2);
  packed_args.pack(offset);
  packed_args.pack(src_info);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim1);
  saved.after(dim2);
  saved.after(offset);
  saved.after(src_info);
  return output_result;
#endif
}

static variable_list AsStridedScatterBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, at::TensorGeometry& self_geometry, std::vector<c10::SymInt>& size, at::TensorGeometry& src_geometry, ::std::optional<c10::SymInt>& storage_offset, std::vector<c10::SymInt>& stride)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto src_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (as_strided_scatter_backward(grad, self_geometry, src_geometry, size, stride, storage_offset)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  if (needs_input_grad[/*src*/1]) {
    auto grad_result = any_grad_defined ? (grad.contiguous().as_strided_symint(size, stride, storage_offset)) : Tensor();
    copy_range(grad_inputs, src_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list AsStridedScatterBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto self_geometry = packed_args.unpack<at::TensorGeometry>();
  auto size = packed_args.unpack<std::vector<c10::SymInt>>();
  auto src_geometry = packed_args.unpack<at::TensorGeometry>();
  auto storage_offset = packed_args.unpack<::std::optional<c10::SymInt>>();
  auto stride = packed_args.unpack<std::vector<c10::SymInt>>();
  return AsStridedScatterBackward0_apply_functional(variable_list(grads), needs_input_grad, self_geometry, size, src_geometry, storage_offset, stride);
#endif
}

variable_list AsStridedScatterBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto src_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ src_ix }),
  };
  return AsStridedScatterBackward0_apply_functional(std::move(grads), needs_input_grad, self_geometry, size, src_geometry, storage_offset, stride);
}

void AsStridedScatterBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_geometry);
    args.collect(size);
    args.collect(src_geometry);
    args.collect(storage_offset);
    args.collect(stride);
}
variable_list AsStridedScatterBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_geometry);
  saved.before(size);
  saved.before(src_geometry);
  saved.before(storage_offset);
  saved.before(stride);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::TensorGeometry>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::TensorGeometry>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), AsStridedScatterBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto src_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ src_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_geometry);
  packed_args.pack(size);
  packed_args.pack(src_geometry);
  packed_args.pack(storage_offset);
  packed_args.pack(stride);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_geometry);
  saved.after(size);
  saved.after(src_geometry);
  saved.after(storage_offset);
  saved.after(stride);
  return output_result;
#endif
}

static variable_list LinalgSolveExBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& A, bool& left, Tensor& LU, Tensor& pivots, Tensor& result)
{
  IndexRangeGenerator gen;
  auto A_ix = gen.range(1);
  auto B_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1]) {
      auto grad_input_mask = std::array<bool, 2>{
        needs_input_grad[0],
        needs_input_grad[1],
      };
    auto grad_result = linalg_solve_backward(grad, result, A, LU, pivots, left, grad_input_mask[1]);
      if (needs_input_grad[/*A*/0]) {
        copy_range(grad_inputs, A_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*B*/1]) {
        copy_range(grad_inputs, B_ix, std::get<1>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list LinalgSolveExBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto A = packed_args.unpack<Tensor>();
  auto left = packed_args.unpack<bool>();
  auto LU = packed_args.unpack<Tensor>();
  auto pivots = packed_args.unpack<Tensor>();
  auto result = packed_args.unpack<Tensor>();
  return LinalgSolveExBackward0_apply_functional(variable_list(grads), needs_input_grad, A, left, LU, pivots, result);
#endif
}

variable_list LinalgSolveExBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto A = A_.unpack();
  auto LU = LU_.unpack(shared_from_this());
  auto pivots = pivots_.unpack(shared_from_this());
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto A_ix = gen.range(1);
  auto B_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ A_ix }),
    task_should_compute_output({ B_ix }),
  };
  return LinalgSolveExBackward0_apply_functional(std::move(grads), needs_input_grad, A, left, LU, pivots, result);
}

void LinalgSolveExBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(A_, false);
    args.collect(left);
    args.collect(LU_, true);
    args.collect(pivots_, true);
    args.collect(result_, true);
}
variable_list LinalgSolveExBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(A_);
  saved.before(left);
  saved.before(LU_);
  saved.before(pivots_);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), LinalgSolveExBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto A = A_.unpack();
  auto LU = LU_.unpack(shared_from_this());
  auto pivots = pivots_.unpack(shared_from_this());
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto A_ix = gen.range(1);
  auto B_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ A_ix }),
    task_should_compute_output({ B_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(A);
  packed_args.pack(left);
  packed_args.pack(LU);
  packed_args.pack(pivots);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(A_);
  saved.after(left);
  saved.after(LU_);
  saved.after(pivots_);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list SortBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim, std::vector<c10::SymInt>& self_sym_sizes, Tensor& indices)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (value_selecting_reduction_backward_symint(grad, dim, indices, self_sym_sizes, true)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SortBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  auto indices = packed_args.unpack<Tensor>();
  return SortBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, self_sym_sizes, indices);
#endif
}

variable_list SortBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto indices = indices_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SortBackward0_apply_functional(std::move(grads), needs_input_grad, dim, self_sym_sizes, indices);
}

void SortBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(self_sym_sizes);
    args.collect(indices_, true);
}
variable_list SortBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(self_sym_sizes);
  saved.before(indices_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SortBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto indices = indices_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(self_sym_sizes);
  packed_args.pack(indices);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(self_sym_sizes);
  saved.after(indices_);
  return output_result;
#endif
}

static variable_list SortBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim, std::vector<c10::SymInt>& self_sym_sizes, Tensor& indices)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (value_selecting_reduction_backward_symint(grad, dim, indices, self_sym_sizes, true)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SortBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  auto indices = packed_args.unpack<Tensor>();
  return SortBackward1_apply_functional(variable_list(grads), needs_input_grad, dim, self_sym_sizes, indices);
#endif
}

variable_list SortBackward1::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto indices = indices_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SortBackward1_apply_functional(std::move(grads), needs_input_grad, dim, self_sym_sizes, indices);
}

void SortBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(self_sym_sizes);
    args.collect(indices_, true);
}
variable_list SortBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(self_sym_sizes);
  saved.before(indices_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SortBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto indices = indices_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(self_sym_sizes);
  packed_args.pack(indices);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(self_sym_sizes);
  saved.after(indices_);
  return output_result;
#endif
}

static variable_list SplitBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim, at::TensorOptions& self_options, std::vector<c10::SymInt>& self_sym_sizes, c10::SymInt& split_size)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (split_backward(grads, split_size, dim, self_sym_sizes, self_options)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SplitBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  auto self_options = packed_args.unpack<at::TensorOptions>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  auto split_size = packed_args.unpack<c10::SymInt>();
  return SplitBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, self_options, self_sym_sizes, split_size);
#endif
}

variable_list SplitBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SplitBackward0_apply_functional(std::move(grads), needs_input_grad, dim, self_options, self_sym_sizes, split_size);
}

void SplitBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(self_options);
    args.collect(self_sym_sizes);
    args.collect(split_size);
}
variable_list SplitBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(self_options);
  saved.before(self_sym_sizes);
  saved.before(split_size);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::TensorOptions>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SplitBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(self_options);
  packed_args.pack(self_sym_sizes);
  packed_args.pack(split_size);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(self_options);
  saved.after(self_sym_sizes);
  saved.after(split_size);
  return output_result;
#endif
}

static variable_list UnsafeSplitBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim, at::TensorOptions& self_options, std::vector<c10::SymInt>& self_sym_sizes, c10::SymInt& split_size)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (split_backward(grads, split_size, dim, self_sym_sizes, self_options)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list UnsafeSplitBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  auto self_options = packed_args.unpack<at::TensorOptions>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  auto split_size = packed_args.unpack<c10::SymInt>();
  return UnsafeSplitBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, self_options, self_sym_sizes, split_size);
#endif
}

variable_list UnsafeSplitBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return UnsafeSplitBackward0_apply_functional(std::move(grads), needs_input_grad, dim, self_options, self_sym_sizes, split_size);
}

void UnsafeSplitBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(self_options);
    args.collect(self_sym_sizes);
    args.collect(split_size);
}
variable_list UnsafeSplitBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(self_options);
  saved.before(self_sym_sizes);
  saved.before(split_size);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::TensorOptions>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), UnsafeSplitBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(self_options);
  packed_args.pack(self_sym_sizes);
  packed_args.pack(split_size);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(self_options);
  saved.after(self_sym_sizes);
  saved.after(split_size);
  return output_result;
#endif
}

static variable_list SplitWithSizesBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim, at::TensorOptions& self_options, std::vector<c10::SymInt>& self_sym_sizes, std::vector<c10::SymInt>& split_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (split_with_sizes_backward(grads, split_sizes, dim, self_sym_sizes, self_options)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SplitWithSizesBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  auto self_options = packed_args.unpack<at::TensorOptions>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  auto split_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return SplitWithSizesBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, self_options, self_sym_sizes, split_sizes);
#endif
}

variable_list SplitWithSizesBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SplitWithSizesBackward0_apply_functional(std::move(grads), needs_input_grad, dim, self_options, self_sym_sizes, split_sizes);
}

void SplitWithSizesBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(self_options);
    args.collect(self_sym_sizes);
    args.collect(split_sizes);
}
variable_list SplitWithSizesBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(self_options);
  saved.before(self_sym_sizes);
  saved.before(split_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::TensorOptions>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SplitWithSizesBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(self_options);
  packed_args.pack(self_sym_sizes);
  packed_args.pack(split_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(self_options);
  saved.after(self_sym_sizes);
  saved.after(split_sizes);
  return output_result;
#endif
}

static variable_list SplitWithSizesBackwardAutogradNestedTensor0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim, Tensor& self, at::TensorOptions& self_options, std::vector<c10::SymInt>& split_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (_nested_split_with_sizes_backward(grads, split_sizes, dim, at::native::get_nested_tensor_impl(self)->get_nested_sizes(), self_options)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SplitWithSizesBackwardAutogradNestedTensor0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  auto self = packed_args.unpack<Tensor>();
  auto self_options = packed_args.unpack<at::TensorOptions>();
  auto split_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return SplitWithSizesBackwardAutogradNestedTensor0_apply_functional(variable_list(grads), needs_input_grad, dim, self, self_options, split_sizes);
#endif
}

variable_list SplitWithSizesBackwardAutogradNestedTensor0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SplitWithSizesBackwardAutogradNestedTensor0_apply_functional(std::move(grads), needs_input_grad, dim, self, self_options, split_sizes);
}

void SplitWithSizesBackwardAutogradNestedTensor0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(self_, false);
    args.collect(self_options);
    args.collect(split_sizes);
}
variable_list SplitWithSizesBackwardAutogradNestedTensor0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(self_);
  saved.before(self_options);
  saved.before(split_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::TensorOptions>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SplitWithSizesBackwardAutogradNestedTensor0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(self);
  packed_args.pack(self_options);
  packed_args.pack(split_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(self_);
  saved.after(self_options);
  saved.after(split_sizes);
  return output_result;
#endif
}

static variable_list UnsafeSplitWithSizesBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim, at::TensorOptions& self_options, std::vector<c10::SymInt>& self_sym_sizes, std::vector<c10::SymInt>& split_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (split_with_sizes_backward(grads, split_sizes, dim, self_sym_sizes, self_options)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list UnsafeSplitWithSizesBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  auto self_options = packed_args.unpack<at::TensorOptions>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  auto split_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return UnsafeSplitWithSizesBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, self_options, self_sym_sizes, split_sizes);
#endif
}

variable_list UnsafeSplitWithSizesBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return UnsafeSplitWithSizesBackward0_apply_functional(std::move(grads), needs_input_grad, dim, self_options, self_sym_sizes, split_sizes);
}

void UnsafeSplitWithSizesBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(self_options);
    args.collect(self_sym_sizes);
    args.collect(split_sizes);
}
variable_list UnsafeSplitWithSizesBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(self_options);
  saved.before(self_sym_sizes);
  saved.before(split_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::TensorOptions>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), UnsafeSplitWithSizesBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(self_options);
  packed_args.pack(self_sym_sizes);
  packed_args.pack(split_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(self_options);
  saved.after(self_sym_sizes);
  saved.after(split_sizes);
  return output_result;
#endif
}

static variable_list SqrtBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad / (2 * result.conj())) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SqrtBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto result = packed_args.unpack<Tensor>();
  return SqrtBackward0_apply_functional(variable_list(grads), needs_input_grad, result);
#endif
}

variable_list SqrtBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SqrtBackward0_apply_functional(std::move(grads), needs_input_grad, result);
}

void SqrtBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(result_, true);
}
variable_list SqrtBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SqrtBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(result_);
  return output_result;
#endif
}

static variable_list SqueezeBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<c10::SymInt>& self_sym_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (unsqueeze_to(grad, self_sym_sizes)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SqueezeBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return SqueezeBackward0_apply_functional(variable_list(grads), needs_input_grad, self_sym_sizes);
#endif
}

variable_list SqueezeBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SqueezeBackward0_apply_functional(std::move(grads), needs_input_grad, self_sym_sizes);
}

void SqueezeBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_sym_sizes);
}
variable_list SqueezeBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SqueezeBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_sym_sizes);
  return output_result;
#endif
}

static variable_list SqueezeBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim, std::vector<c10::SymInt>& self_sym_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (unsqueeze_to(grad, dim, self_sym_sizes)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SqueezeBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return SqueezeBackward1_apply_functional(variable_list(grads), needs_input_grad, dim, self_sym_sizes);
#endif
}

variable_list SqueezeBackward1::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SqueezeBackward1_apply_functional(std::move(grads), needs_input_grad, dim, self_sym_sizes);
}

void SqueezeBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(self_sym_sizes);
}
variable_list SqueezeBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(self_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SqueezeBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(self_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(self_sym_sizes);
  return output_result;
#endif
}

static variable_list SqueezeBackwardAutogradNestedTensor0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.unsqueeze(dim)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SqueezeBackwardAutogradNestedTensor0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  return SqueezeBackwardAutogradNestedTensor0_apply_functional(variable_list(grads), needs_input_grad, dim);
#endif
}

variable_list SqueezeBackwardAutogradNestedTensor0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SqueezeBackwardAutogradNestedTensor0_apply_functional(std::move(grads), needs_input_grad, dim);
}

void SqueezeBackwardAutogradNestedTensor0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
}
variable_list SqueezeBackwardAutogradNestedTensor0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SqueezeBackwardAutogradNestedTensor0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  return output_result;
#endif
}

static variable_list SqueezeBackward2_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<int64_t>& dim, std::vector<c10::SymInt>& self_sym_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (unsqueeze_to(grad, dim, self_sym_sizes)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SqueezeBackward2_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<std::vector<int64_t>>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return SqueezeBackward2_apply_functional(variable_list(grads), needs_input_grad, dim, self_sym_sizes);
#endif
}

variable_list SqueezeBackward2::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SqueezeBackward2_apply_functional(std::move(grads), needs_input_grad, dim, self_sym_sizes);
}

void SqueezeBackward2::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(self_sym_sizes);
}
variable_list SqueezeBackward2::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(self_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SqueezeBackward2_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(self_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(self_sym_sizes);
  return output_result;
#endif
}

static variable_list SqueezeBackwardAutogradNestedTensor1_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<int64_t>& dim, int64_t& self_dim)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (unsqueeze_multiple(grad, dim, self_dim)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SqueezeBackwardAutogradNestedTensor1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<std::vector<int64_t>>();
  auto self_dim = packed_args.unpack<int64_t>();
  return SqueezeBackwardAutogradNestedTensor1_apply_functional(variable_list(grads), needs_input_grad, dim, self_dim);
#endif
}

variable_list SqueezeBackwardAutogradNestedTensor1::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SqueezeBackwardAutogradNestedTensor1_apply_functional(std::move(grads), needs_input_grad, dim, self_dim);
}

void SqueezeBackwardAutogradNestedTensor1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(self_dim);
}
variable_list SqueezeBackwardAutogradNestedTensor1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(self_dim);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SqueezeBackwardAutogradNestedTensor1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(self_dim);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(self_dim);
  return output_result;
#endif
}

static variable_list SqueezeBackward3_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<c10::SymInt>& self_sym_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (unsqueeze_to(grad, self_sym_sizes)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SqueezeBackward3_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return SqueezeBackward3_apply_functional(variable_list(grads), needs_input_grad, self_sym_sizes);
#endif
}

variable_list SqueezeBackward3::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SqueezeBackward3_apply_functional(std::move(grads), needs_input_grad, self_sym_sizes);
}

void SqueezeBackward3::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_sym_sizes);
}
variable_list SqueezeBackward3::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SqueezeBackward3_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_sym_sizes);
  return output_result;
#endif
}

static variable_list SqueezeBackward4_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim, std::vector<c10::SymInt>& self_sym_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (unsqueeze_to(grad, dim, self_sym_sizes)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SqueezeBackward4_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return SqueezeBackward4_apply_functional(variable_list(grads), needs_input_grad, dim, self_sym_sizes);
#endif
}

variable_list SqueezeBackward4::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SqueezeBackward4_apply_functional(std::move(grads), needs_input_grad, dim, self_sym_sizes);
}

void SqueezeBackward4::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(self_sym_sizes);
}
variable_list SqueezeBackward4::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(self_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SqueezeBackward4_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(self_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(self_sym_sizes);
  return output_result;
#endif
}

static variable_list SqueezeBackward5_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<int64_t>& dim, std::vector<c10::SymInt>& self_sym_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (unsqueeze_to(grad, dim, self_sym_sizes)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SqueezeBackward5_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<std::vector<int64_t>>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return SqueezeBackward5_apply_functional(variable_list(grads), needs_input_grad, dim, self_sym_sizes);
#endif
}

variable_list SqueezeBackward5::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SqueezeBackward5_apply_functional(std::move(grads), needs_input_grad, dim, self_sym_sizes);
}

void SqueezeBackward5::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(self_sym_sizes);
}
variable_list SqueezeBackward5::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(self_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SqueezeBackward5_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(self_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(self_sym_sizes);
  return output_result;
#endif
}

static variable_list StdBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, ::std::optional<at::Scalar>& correction, c10::OptionalArray<int64_t>& dim, bool& keepdim, Tensor& self, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (std_backward(result, grad, self, dim, correction, keepdim)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list StdBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto correction = packed_args.unpack<::std::optional<at::Scalar>>();
  auto dim = packed_args.unpack<c10::OptionalArray<int64_t>>();
  auto keepdim = packed_args.unpack<bool>();
  auto self = packed_args.unpack<Tensor>();
  auto result = packed_args.unpack<Tensor>();
  return StdBackward0_apply_functional(variable_list(grads), needs_input_grad, correction, dim, keepdim, self, result);
#endif
}

variable_list StdBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return StdBackward0_apply_functional(std::move(grads), needs_input_grad, correction, dim, keepdim, self, result);
}

void StdBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(correction);
    args.collect(dim);
    args.collect(keepdim);
    args.collect(self_, false);
    args.collect(result_, true);
}
variable_list StdBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(correction);
  saved.before(dim);
  saved.before(keepdim);
  saved.before(self_);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<at::Scalar>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::OptionalArray<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), StdBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(correction);
  packed_args.pack(dim);
  packed_args.pack(keepdim);
  packed_args.pack(self);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(correction);
  saved.after(dim);
  saved.after(keepdim);
  saved.after(self_);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list StdMeanBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, ::std::optional<at::Scalar>& correction, c10::OptionalArray<int64_t>& dim, bool& keepdim, Tensor& self, Tensor& result0)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (std_mean_backward(grads[0], grads[1], self, result0, dim, correction, keepdim)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list StdMeanBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto correction = packed_args.unpack<::std::optional<at::Scalar>>();
  auto dim = packed_args.unpack<c10::OptionalArray<int64_t>>();
  auto keepdim = packed_args.unpack<bool>();
  auto self = packed_args.unpack<Tensor>();
  auto result0 = packed_args.unpack<Tensor>();
  return StdMeanBackward0_apply_functional(variable_list(grads), needs_input_grad, correction, dim, keepdim, self, result0);
#endif
}

variable_list StdMeanBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto result0 = result0_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return StdMeanBackward0_apply_functional(std::move(grads), needs_input_grad, correction, dim, keepdim, self, result0);
}

void StdMeanBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(correction);
    args.collect(dim);
    args.collect(keepdim);
    args.collect(self_, false);
    args.collect(result0_, true);
}
variable_list StdMeanBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(correction);
  saved.before(dim);
  saved.before(keepdim);
  saved.before(self_);
  saved.before(result0_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<at::Scalar>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::OptionalArray<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), StdMeanBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto result0 = result0_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(correction);
  packed_args.pack(dim);
  packed_args.pack(keepdim);
  packed_args.pack(self);
  packed_args.pack(result0);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(correction);
  saved.after(dim);
  saved.after(keepdim);
  saved.after(self_);
  saved.after(result0_);
  return output_result;
#endif
}

static variable_list SubBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, at::Scalar& alpha, at::ScalarType& other_scalar_type, at::ScalarType& self_scalar_type)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*other*/1]) {
    auto grad_result = any_grad_defined ? (handle_r_to_c(other_scalar_type, maybe_multiply(-grad, alpha.conj()))) : Tensor();
    copy_range(grad_inputs, other_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (handle_r_to_c(self_scalar_type, grad)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SubBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto alpha = packed_args.unpack<at::Scalar>();
  auto other_scalar_type = packed_args.unpack<at::ScalarType>();
  auto self_scalar_type = packed_args.unpack<at::ScalarType>();
  return SubBackward0_apply_functional(variable_list(grads), needs_input_grad, alpha, other_scalar_type, self_scalar_type);
#endif
}

variable_list SubBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  return SubBackward0_apply_functional(std::move(grads), needs_input_grad, alpha, other_scalar_type, self_scalar_type);
}

void SubBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(alpha);
    args.collect(other_scalar_type);
    args.collect(self_scalar_type);
}
variable_list SubBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(alpha);
  saved.before(other_scalar_type);
  saved.before(self_scalar_type);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::ScalarType>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::ScalarType>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SubBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(alpha);
  packed_args.pack(other_scalar_type);
  packed_args.pack(self_scalar_type);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(alpha);
  saved.after(other_scalar_type);
  saved.after(self_scalar_type);
  return output_result;
#endif
}

static variable_list SubBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, at::ScalarType& self_scalar_type)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (handle_r_to_c(self_scalar_type, grad)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SubBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_scalar_type = packed_args.unpack<at::ScalarType>();
  return SubBackward1_apply_functional(variable_list(grads), needs_input_grad, self_scalar_type);
#endif
}

variable_list SubBackward1::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SubBackward1_apply_functional(std::move(grads), needs_input_grad, self_scalar_type);
}

void SubBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_scalar_type);
}
variable_list SubBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_scalar_type);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::ScalarType>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SubBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_scalar_type);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_scalar_type);
  return output_result;
#endif
}

static variable_list RsubBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, at::Scalar& alpha, at::ScalarType& other_scalar_type, at::ScalarType& self_scalar_type)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*other*/1]) {
    auto grad_result = any_grad_defined ? (handle_r_to_c(other_scalar_type, grad)) : Tensor();
    copy_range(grad_inputs, other_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (handle_r_to_c(self_scalar_type, maybe_multiply(-grad, alpha.conj()))) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list RsubBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto alpha = packed_args.unpack<at::Scalar>();
  auto other_scalar_type = packed_args.unpack<at::ScalarType>();
  auto self_scalar_type = packed_args.unpack<at::ScalarType>();
  return RsubBackward0_apply_functional(variable_list(grads), needs_input_grad, alpha, other_scalar_type, self_scalar_type);
#endif
}

variable_list RsubBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  return RsubBackward0_apply_functional(std::move(grads), needs_input_grad, alpha, other_scalar_type, self_scalar_type);
}

void RsubBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(alpha);
    args.collect(other_scalar_type);
    args.collect(self_scalar_type);
}
variable_list RsubBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(alpha);
  saved.before(other_scalar_type);
  saved.before(self_scalar_type);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::ScalarType>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::ScalarType>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), RsubBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(alpha);
  packed_args.pack(other_scalar_type);
  packed_args.pack(self_scalar_type);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(alpha);
  saved.after(other_scalar_type);
  saved.after(self_scalar_type);
  return output_result;
#endif
}

static variable_list RsubBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, at::Scalar& alpha, at::ScalarType& self_scalar_type)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (handle_r_to_c(self_scalar_type, maybe_multiply(-grad, alpha.conj()))) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list RsubBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto alpha = packed_args.unpack<at::Scalar>();
  auto self_scalar_type = packed_args.unpack<at::ScalarType>();
  return RsubBackward1_apply_functional(variable_list(grads), needs_input_grad, alpha, self_scalar_type);
#endif
}

variable_list RsubBackward1::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return RsubBackward1_apply_functional(std::move(grads), needs_input_grad, alpha, self_scalar_type);
}

void RsubBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(alpha);
    args.collect(self_scalar_type);
}
variable_list RsubBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(alpha);
  saved.before(self_scalar_type);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::ScalarType>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), RsubBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(alpha);
  packed_args.pack(self_scalar_type);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(alpha);
  saved.after(self_scalar_type);
  return output_result;
#endif
}

static variable_list SumBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<c10::SymInt>& self_sym_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.expand_symint(self_sym_sizes)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SumBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return SumBackward0_apply_functional(variable_list(grads), needs_input_grad, self_sym_sizes);
#endif
}

variable_list SumBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SumBackward0_apply_functional(std::move(grads), needs_input_grad, self_sym_sizes);
}

void SumBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_sym_sizes);
}
variable_list SumBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SumBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_sym_sizes);
  return output_result;
#endif
}

static variable_list SumBackwardAutogradNestedTensor0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (ones_like(self) * grad) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SumBackwardAutogradNestedTensor0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  return SumBackwardAutogradNestedTensor0_apply_functional(variable_list(grads), needs_input_grad, self);
#endif
}

variable_list SumBackwardAutogradNestedTensor0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SumBackwardAutogradNestedTensor0_apply_functional(std::move(grads), needs_input_grad, self);
}

void SumBackwardAutogradNestedTensor0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list SumBackwardAutogradNestedTensor0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SumBackwardAutogradNestedTensor0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list SumBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, c10::OptionalArray<int64_t>& dim, bool& keepdim, std::vector<c10::SymInt>& self_sym_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (sum_backward(grad, self_sym_sizes, dim, keepdim)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SumBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<c10::OptionalArray<int64_t>>();
  auto keepdim = packed_args.unpack<bool>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return SumBackward1_apply_functional(variable_list(grads), needs_input_grad, dim, keepdim, self_sym_sizes);
#endif
}

variable_list SumBackward1::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SumBackward1_apply_functional(std::move(grads), needs_input_grad, dim, keepdim, self_sym_sizes);
}

void SumBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(keepdim);
    args.collect(self_sym_sizes);
}
variable_list SumBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(keepdim);
  saved.before(self_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::OptionalArray<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SumBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(keepdim);
  packed_args.pack(self_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(keepdim);
  saved.after(self_sym_sizes);
  return output_result;
#endif
}

static variable_list SumBackwardAutogradNestedTensor1_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, c10::OptionalArray<int64_t>& dim, bool& keepdim, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (_nested_sum_backward(grad, self, dim, keepdim)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SumBackwardAutogradNestedTensor1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<c10::OptionalArray<int64_t>>();
  auto keepdim = packed_args.unpack<bool>();
  auto self = packed_args.unpack<Tensor>();
  return SumBackwardAutogradNestedTensor1_apply_functional(variable_list(grads), needs_input_grad, dim, keepdim, self);
#endif
}

variable_list SumBackwardAutogradNestedTensor1::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SumBackwardAutogradNestedTensor1_apply_functional(std::move(grads), needs_input_grad, dim, keepdim, self);
}

void SumBackwardAutogradNestedTensor1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(keepdim);
    args.collect(self_, false);
}
variable_list SumBackwardAutogradNestedTensor1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(keepdim);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::OptionalArray<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SumBackwardAutogradNestedTensor1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(keepdim);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(keepdim);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list NansumBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, c10::OptionalArray<int64_t>& dim, bool& keepdim, Tensor& self, at::ScalarType& self_scalar_type)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (nansum_backward(grad.to(self_scalar_type), self, dim, keepdim)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list NansumBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<c10::OptionalArray<int64_t>>();
  auto keepdim = packed_args.unpack<bool>();
  auto self = packed_args.unpack<Tensor>();
  auto self_scalar_type = packed_args.unpack<at::ScalarType>();
  return NansumBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, keepdim, self, self_scalar_type);
#endif
}

variable_list NansumBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return NansumBackward0_apply_functional(std::move(grads), needs_input_grad, dim, keepdim, self, self_scalar_type);
}

void NansumBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(keepdim);
    args.collect(self_, false);
    args.collect(self_scalar_type);
}
variable_list NansumBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(keepdim);
  saved.before(self_);
  saved.before(self_scalar_type);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::OptionalArray<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::ScalarType>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), NansumBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(keepdim);
  packed_args.pack(self);
  packed_args.pack(self_scalar_type);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(keepdim);
  saved.after(self_);
  saved.after(self_scalar_type);
  return output_result;
#endif
}

static variable_list LinalgSvdBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, bool& full_matrices, Tensor& S, c10::SymInt& S_sym_argsize_minus_1, Tensor& U, Tensor& Vh)
{
  IndexRangeGenerator gen;
  auto A_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad_S = grads[1];
  const auto& grad_U = grads[0];
  const auto& grad_Vh = grads[2];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*A*/0]) {
    auto grad_result = any_grad_defined ? (svd_backward(full_matrices && grad_U.defined() ? grad_U.narrow_symint(-1, 0, S_sym_argsize_minus_1) : grad_U, grad_S, full_matrices && grad_Vh.defined() ? grad_Vh.narrow_symint(-2, 0, S_sym_argsize_minus_1) : grad_Vh, full_matrices ? U.narrow_symint(-1, 0, S_sym_argsize_minus_1) : U, S, full_matrices ? Vh.narrow_symint(-2, 0, S_sym_argsize_minus_1) : Vh)) : Tensor();
    copy_range(grad_inputs, A_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list LinalgSvdBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto full_matrices = packed_args.unpack<bool>();
  auto S = packed_args.unpack<Tensor>();
  auto S_sym_argsize_minus_1 = packed_args.unpack<c10::SymInt>();
  auto U = packed_args.unpack<Tensor>();
  auto Vh = packed_args.unpack<Tensor>();
  return LinalgSvdBackward0_apply_functional(variable_list(grads), needs_input_grad, full_matrices, S, S_sym_argsize_minus_1, U, Vh);
#endif
}

variable_list LinalgSvdBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto S = S_.unpack(shared_from_this());
  auto U = U_.unpack(shared_from_this());
  auto Vh = Vh_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto A_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ A_ix }),
  };
  return LinalgSvdBackward0_apply_functional(std::move(grads), needs_input_grad, full_matrices, S, S_sym_argsize_minus_1, U, Vh);
}

void LinalgSvdBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(full_matrices);
    args.collect(S_, true);
    args.collect(S_sym_argsize_minus_1);
    args.collect(U_, true);
    args.collect(Vh_, true);
}
variable_list LinalgSvdBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(full_matrices);
  saved.before(S_);
  saved.before(S_sym_argsize_minus_1);
  saved.before(U_);
  saved.before(Vh_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), LinalgSvdBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto S = S_.unpack(shared_from_this());
  auto U = U_.unpack(shared_from_this());
  auto Vh = Vh_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto A_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ A_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(full_matrices);
  packed_args.pack(S);
  packed_args.pack(S_sym_argsize_minus_1);
  packed_args.pack(U);
  packed_args.pack(Vh);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(full_matrices);
  saved.after(S_);
  saved.after(S_sym_argsize_minus_1);
  saved.after(U_);
  saved.after(Vh_);
  return output_result;
#endif
}

static variable_list LinalgEighBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& eigenvalues, Tensor& eigenvectors)
{
  IndexRangeGenerator gen;
  auto A_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*A*/0]) {
    auto grad_result = any_grad_defined ? (linalg_eig_backward(grads[0], grads[1], eigenvalues, eigenvectors, /*is_hermitian=*/true)) : Tensor();
    copy_range(grad_inputs, A_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list LinalgEighBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto eigenvalues = packed_args.unpack<Tensor>();
  auto eigenvectors = packed_args.unpack<Tensor>();
  return LinalgEighBackward0_apply_functional(variable_list(grads), needs_input_grad, eigenvalues, eigenvectors);
#endif
}

variable_list LinalgEighBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto eigenvalues = eigenvalues_.unpack(shared_from_this());
  auto eigenvectors = eigenvectors_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto A_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ A_ix }),
  };
  return LinalgEighBackward0_apply_functional(std::move(grads), needs_input_grad, eigenvalues, eigenvectors);
}

void LinalgEighBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(eigenvalues_, true);
    args.collect(eigenvectors_, true);
}
variable_list LinalgEighBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(eigenvalues_);
  saved.before(eigenvectors_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), LinalgEighBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto eigenvalues = eigenvalues_.unpack(shared_from_this());
  auto eigenvectors = eigenvectors_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto A_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ A_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(eigenvalues);
  packed_args.pack(eigenvectors);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(eigenvalues_);
  saved.after(eigenvectors_);
  return output_result;
#endif
}

static variable_list LinalgEigBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, at::ScalarType& self_scalar_type, Tensor& eigenvalues, Tensor& eigenvectors)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (handle_r_to_c(self_scalar_type, linalg_eig_backward(grads[0], grads[1], eigenvalues, eigenvectors, /*is_hermitian=*/false))) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list LinalgEigBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_scalar_type = packed_args.unpack<at::ScalarType>();
  auto eigenvalues = packed_args.unpack<Tensor>();
  auto eigenvectors = packed_args.unpack<Tensor>();
  return LinalgEigBackward0_apply_functional(variable_list(grads), needs_input_grad, self_scalar_type, eigenvalues, eigenvectors);
#endif
}

variable_list LinalgEigBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto eigenvalues = eigenvalues_.unpack(shared_from_this());
  auto eigenvectors = eigenvectors_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return LinalgEigBackward0_apply_functional(std::move(grads), needs_input_grad, self_scalar_type, eigenvalues, eigenvectors);
}

void LinalgEigBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_scalar_type);
    args.collect(eigenvalues_, true);
    args.collect(eigenvectors_, true);
}
variable_list LinalgEigBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_scalar_type);
  saved.before(eigenvalues_);
  saved.before(eigenvectors_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::ScalarType>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), LinalgEigBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto eigenvalues = eigenvalues_.unpack(shared_from_this());
  auto eigenvectors = eigenvectors_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_scalar_type);
  packed_args.pack(eigenvalues);
  packed_args.pack(eigenvectors);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_scalar_type);
  saved.after(eigenvalues_);
  saved.after(eigenvectors_);
  return output_result;
#endif
}

static variable_list TBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.t()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list TBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return TBackward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list TBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return TBackward0_apply_functional(std::move(grads), needs_input_grad);
}

void TBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list TBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), TBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list TBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.t()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list TBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return TBackward1_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list TBackward1::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return TBackward1_apply_functional(std::move(grads), needs_input_grad);
}

void TBackward1::compiled_args(CompiledNodeArgs& args) const {

}
variable_list TBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), TBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list FlipBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<int64_t>& dims)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.flip(dims)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list FlipBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dims = packed_args.unpack<std::vector<int64_t>>();
  return FlipBackward0_apply_functional(variable_list(grads), needs_input_grad, dims);
#endif
}

variable_list FlipBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return FlipBackward0_apply_functional(std::move(grads), needs_input_grad, dims);
}

void FlipBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dims);
}
variable_list FlipBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dims);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), FlipBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dims);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dims);
  return output_result;
#endif
}

static variable_list RollBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<int64_t>& dims, std::vector<c10::SymInt>& shifts)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.roll_symint(fmap(reverse_list_symint(shifts), [](c10::SymInt i){return -i;}), reverse_list(dims))) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list RollBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dims = packed_args.unpack<std::vector<int64_t>>();
  auto shifts = packed_args.unpack<std::vector<c10::SymInt>>();
  return RollBackward0_apply_functional(variable_list(grads), needs_input_grad, dims, shifts);
#endif
}

variable_list RollBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return RollBackward0_apply_functional(std::move(grads), needs_input_grad, dims, shifts);
}

void RollBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dims);
    args.collect(shifts);
}
variable_list RollBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dims);
  saved.before(shifts);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), RollBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dims);
  packed_args.pack(shifts);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dims);
  saved.after(shifts);
  return output_result;
#endif
}

static variable_list Rot90Backward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<int64_t>& dims, int64_t& k)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.rot90(-k, dims)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list Rot90Backward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dims = packed_args.unpack<std::vector<int64_t>>();
  auto k = packed_args.unpack<int64_t>();
  return Rot90Backward0_apply_functional(variable_list(grads), needs_input_grad, dims, k);
#endif
}

variable_list Rot90Backward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return Rot90Backward0_apply_functional(std::move(grads), needs_input_grad, dims, k);
}

void Rot90Backward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dims);
    args.collect(k);
}
variable_list Rot90Backward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dims);
  saved.before(k);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), Rot90Backward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dims);
  packed_args.pack(k);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dims);
  saved.after(k);
  return output_result;
#endif
}

static variable_list TakeBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& index, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (take_backward(grad, self, index)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list TakeBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto index = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<Tensor>();
  return TakeBackward0_apply_functional(variable_list(grads), needs_input_grad, index, self);
#endif
}

variable_list TakeBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto index = index_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return TakeBackward0_apply_functional(std::move(grads), needs_input_grad, index, self);
}

void TakeBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(index_, false);
    args.collect(self_, false);
}
variable_list TakeBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(index_);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), TakeBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto index = index_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(index);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(index_);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list TanBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad * (1 + result.pow(2)).conj()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list TanBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto result = packed_args.unpack<Tensor>();
  return TanBackward0_apply_functional(variable_list(grads), needs_input_grad, result);
#endif
}

variable_list TanBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return TanBackward0_apply_functional(std::move(grads), needs_input_grad, result);
}

void TanBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(result_, true);
}
variable_list TanBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), TanBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(result_);
  return output_result;
#endif
}

static variable_list TanhBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (tanh_backward(grad, result)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list TanhBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto result = packed_args.unpack<Tensor>();
  return TanhBackward0_apply_functional(variable_list(grads), needs_input_grad, result);
#endif
}

variable_list TanhBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return TanhBackward0_apply_functional(std::move(grads), needs_input_grad, result);
}

void TanhBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(result_, true);
}
variable_list TanhBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), TanhBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(result_);
  return output_result;
#endif
}

static variable_list TopkBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim, std::vector<c10::SymInt>& self_sym_sizes, Tensor& indices)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (value_selecting_reduction_backward_symint(grad, dim, indices, self_sym_sizes, true)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list TopkBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  auto indices = packed_args.unpack<Tensor>();
  return TopkBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, self_sym_sizes, indices);
#endif
}

variable_list TopkBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto indices = indices_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return TopkBackward0_apply_functional(std::move(grads), needs_input_grad, dim, self_sym_sizes, indices);
}

void TopkBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(self_sym_sizes);
    args.collect(indices_, true);
}
variable_list TopkBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(self_sym_sizes);
  saved.before(indices_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), TopkBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto indices = indices_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(self_sym_sizes);
  packed_args.pack(indices);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(self_sym_sizes);
  saved.after(indices_);
  return output_result;
#endif
}

static variable_list TraceBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<c10::SymInt>& self_sym_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (trace_backward_symint(grad, self_sym_sizes)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list TraceBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return TraceBackward0_apply_functional(variable_list(grads), needs_input_grad, self_sym_sizes);
#endif
}

variable_list TraceBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return TraceBackward0_apply_functional(std::move(grads), needs_input_grad, self_sym_sizes);
}

void TraceBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_sym_sizes);
}
variable_list TraceBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), TraceBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_sym_sizes);
  return output_result;
#endif
}

static variable_list TransposeBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim0, int64_t& dim1)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.transpose(dim0, dim1)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list TransposeBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim0 = packed_args.unpack<int64_t>();
  auto dim1 = packed_args.unpack<int64_t>();
  return TransposeBackward0_apply_functional(variable_list(grads), needs_input_grad, dim0, dim1);
#endif
}

variable_list TransposeBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return TransposeBackward0_apply_functional(std::move(grads), needs_input_grad, dim0, dim1);
}

void TransposeBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim0);
    args.collect(dim1);
}
variable_list TransposeBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim0);
  saved.before(dim1);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), TransposeBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim0);
  packed_args.pack(dim1);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim0);
  saved.after(dim1);
  return output_result;
#endif
}

static variable_list TransposeBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim0, int64_t& dim1)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.transpose(dim0, dim1)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list TransposeBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim0 = packed_args.unpack<int64_t>();
  auto dim1 = packed_args.unpack<int64_t>();
  return TransposeBackward1_apply_functional(variable_list(grads), needs_input_grad, dim0, dim1);
#endif
}

variable_list TransposeBackward1::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return TransposeBackward1_apply_functional(std::move(grads), needs_input_grad, dim0, dim1);
}

void TransposeBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim0);
    args.collect(dim1);
}
variable_list TransposeBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim0);
  saved.before(dim1);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), TransposeBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim0);
  packed_args.pack(dim1);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim0);
  saved.after(dim1);
  return output_result;
#endif
}

static variable_list TriangularSolveBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& A, Tensor& self, bool& transpose, bool& unitriangular, bool& upper, Tensor& solution)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto A_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad_cloned_coefficient = grads[1];
  const auto& grad_solution = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1]) {
      auto grad_input_mask = std::array<bool, 2>{
        needs_input_grad[0],
        needs_input_grad[1],
      };
    auto grad_result = triangular_solve_backward(grad_solution, grad_cloned_coefficient, self, A, solution, upper, transpose, unitriangular, grad_input_mask);
      if (needs_input_grad[/*self*/0]) {
        copy_range(grad_inputs, self_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*A*/1]) {
        copy_range(grad_inputs, A_ix, std::get<1>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list TriangularSolveBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto A = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<Tensor>();
  auto transpose = packed_args.unpack<bool>();
  auto unitriangular = packed_args.unpack<bool>();
  auto upper = packed_args.unpack<bool>();
  auto solution = packed_args.unpack<Tensor>();
  return TriangularSolveBackward0_apply_functional(variable_list(grads), needs_input_grad, A, self, transpose, unitriangular, upper, solution);
#endif
}

variable_list TriangularSolveBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto A = A_.unpack();
  auto self = self_.unpack();
  auto solution = solution_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto A_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ A_ix }),
  };
  return TriangularSolveBackward0_apply_functional(std::move(grads), needs_input_grad, A, self, transpose, unitriangular, upper, solution);
}

void TriangularSolveBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(A_, false);
    args.collect(self_, false);
    args.collect(transpose);
    args.collect(unitriangular);
    args.collect(upper);
    args.collect(solution_, true);
}
variable_list TriangularSolveBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(A_);
  saved.before(self_);
  saved.before(transpose);
  saved.before(unitriangular);
  saved.before(upper);
  saved.before(solution_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), TriangularSolveBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto A = A_.unpack();
  auto self = self_.unpack();
  auto solution = solution_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto A_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ A_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(A);
  packed_args.pack(self);
  packed_args.pack(transpose);
  packed_args.pack(unitriangular);
  packed_args.pack(upper);
  packed_args.pack(solution);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(A_);
  saved.after(self_);
  saved.after(transpose);
  saved.after(unitriangular);
  saved.after(upper);
  saved.after(solution_);
  return output_result;
#endif
}

static variable_list LinalgSolveTriangularBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, bool& left, Tensor& self, bool& unitriangular, bool& upper, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto B_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1]) {
      auto grad_input_mask = std::array<bool, 2>{
        needs_input_grad[0],
        needs_input_grad[1],
      };
    auto grad_result = linalg_solve_triangular_backward(grad, self, result, upper, left, unitriangular, grad_input_mask);
      if (needs_input_grad[/*self*/0]) {
        copy_range(grad_inputs, self_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*B*/1]) {
        copy_range(grad_inputs, B_ix, std::get<1>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list LinalgSolveTriangularBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto left = packed_args.unpack<bool>();
  auto self = packed_args.unpack<Tensor>();
  auto unitriangular = packed_args.unpack<bool>();
  auto upper = packed_args.unpack<bool>();
  auto result = packed_args.unpack<Tensor>();
  return LinalgSolveTriangularBackward0_apply_functional(variable_list(grads), needs_input_grad, left, self, unitriangular, upper, result);
#endif
}

variable_list LinalgSolveTriangularBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto B_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ B_ix }),
  };
  return LinalgSolveTriangularBackward0_apply_functional(std::move(grads), needs_input_grad, left, self, unitriangular, upper, result);
}

void LinalgSolveTriangularBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(left);
    args.collect(self_, false);
    args.collect(unitriangular);
    args.collect(upper);
    args.collect(result_, true);
}
variable_list LinalgSolveTriangularBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(left);
  saved.before(self_);
  saved.before(unitriangular);
  saved.before(upper);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), LinalgSolveTriangularBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto B_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ B_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(left);
  packed_args.pack(self);
  packed_args.pack(unitriangular);
  packed_args.pack(upper);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(left);
  saved.after(self_);
  saved.after(unitriangular);
  saved.after(upper);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list TrilBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& diagonal)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.tril(diagonal)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list TrilBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto diagonal = packed_args.unpack<int64_t>();
  return TrilBackward0_apply_functional(variable_list(grads), needs_input_grad, diagonal);
#endif
}

variable_list TrilBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return TrilBackward0_apply_functional(std::move(grads), needs_input_grad, diagonal);
}

void TrilBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(diagonal);
}
variable_list TrilBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(diagonal);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), TrilBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(diagonal);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(diagonal);
  return output_result;
#endif
}

static variable_list TriuBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& diagonal)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.triu(diagonal)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list TriuBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto diagonal = packed_args.unpack<int64_t>();
  return TriuBackward0_apply_functional(variable_list(grads), needs_input_grad, diagonal);
#endif
}

variable_list TriuBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return TriuBackward0_apply_functional(std::move(grads), needs_input_grad, diagonal);
}

void TriuBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(diagonal);
}
variable_list TriuBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(diagonal);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), TriuBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(diagonal);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(diagonal);
  return output_result;
#endif
}

static variable_list TruncBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (zeros_like(grad)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list TruncBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return TruncBackward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list TruncBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return TruncBackward0_apply_functional(std::move(grads), needs_input_grad);
}

void TruncBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list TruncBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), TruncBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list ToDenseBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, ::std::optional<bool>& masked_grad, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (to_dense_backward(grad, self, masked_grad)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ToDenseBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto masked_grad = packed_args.unpack<::std::optional<bool>>();
  auto self = packed_args.unpack<Tensor>();
  return ToDenseBackward0_apply_functional(variable_list(grads), needs_input_grad, masked_grad, self);
#endif
}

variable_list ToDenseBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ToDenseBackward0_apply_functional(std::move(grads), needs_input_grad, masked_grad, self);
}

void ToDenseBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(masked_grad);
    args.collect(self_, false);
}
variable_list ToDenseBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(masked_grad);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<bool>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ToDenseBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(masked_grad);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(masked_grad);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list ToSparseBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, at::Layout& self_layout, c10::OptionalArray<c10::SymInt>& self_self_sym_blocksize_opt)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (to_sparse_backward(grad, self_layout, self_self_sym_blocksize_opt)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ToSparseBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_layout = packed_args.unpack<at::Layout>();
  auto self_self_sym_blocksize_opt = packed_args.unpack<c10::OptionalArray<c10::SymInt>>();
  return ToSparseBackward0_apply_functional(variable_list(grads), needs_input_grad, self_layout, self_self_sym_blocksize_opt);
#endif
}

variable_list ToSparseBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ToSparseBackward0_apply_functional(std::move(grads), needs_input_grad, self_layout, self_self_sym_blocksize_opt);
}

void ToSparseBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_layout);
    args.collect(self_self_sym_blocksize_opt);
}
variable_list ToSparseBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_layout);
  saved.before(self_self_sym_blocksize_opt);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Layout>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::OptionalArray<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ToSparseBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_layout);
  packed_args.pack(self_self_sym_blocksize_opt);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_layout);
  saved.after(self_self_sym_blocksize_opt);
  return output_result;
#endif
}

static variable_list ToSparseBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, at::Layout& self_layout, c10::OptionalArray<c10::SymInt>& self_self_sym_blocksize_opt)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (to_sparse_backward(grad, self_layout, self_self_sym_blocksize_opt)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ToSparseBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_layout = packed_args.unpack<at::Layout>();
  auto self_self_sym_blocksize_opt = packed_args.unpack<c10::OptionalArray<c10::SymInt>>();
  return ToSparseBackward1_apply_functional(variable_list(grads), needs_input_grad, self_layout, self_self_sym_blocksize_opt);
#endif
}

variable_list ToSparseBackward1::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ToSparseBackward1_apply_functional(std::move(grads), needs_input_grad, self_layout, self_self_sym_blocksize_opt);
}

void ToSparseBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_layout);
    args.collect(self_self_sym_blocksize_opt);
}
variable_list ToSparseBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_layout);
  saved.before(self_self_sym_blocksize_opt);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Layout>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::OptionalArray<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ToSparseBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_layout);
  packed_args.pack(self_self_sym_blocksize_opt);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_layout);
  saved.after(self_self_sym_blocksize_opt);
  return output_result;
#endif
}

static variable_list ToSparseCsrBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, at::Layout& self_layout, c10::OptionalArray<c10::SymInt>& self_self_sym_blocksize_opt)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (to_sparse_backward(grad, self_layout, self_self_sym_blocksize_opt)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ToSparseCsrBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_layout = packed_args.unpack<at::Layout>();
  auto self_self_sym_blocksize_opt = packed_args.unpack<c10::OptionalArray<c10::SymInt>>();
  return ToSparseCsrBackward0_apply_functional(variable_list(grads), needs_input_grad, self_layout, self_self_sym_blocksize_opt);
#endif
}

variable_list ToSparseCsrBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ToSparseCsrBackward0_apply_functional(std::move(grads), needs_input_grad, self_layout, self_self_sym_blocksize_opt);
}

void ToSparseCsrBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_layout);
    args.collect(self_self_sym_blocksize_opt);
}
variable_list ToSparseCsrBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_layout);
  saved.before(self_self_sym_blocksize_opt);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Layout>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::OptionalArray<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ToSparseCsrBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_layout);
  packed_args.pack(self_self_sym_blocksize_opt);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_layout);
  saved.after(self_self_sym_blocksize_opt);
  return output_result;
#endif
}

static variable_list ToSparseCscBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, at::Layout& self_layout, c10::OptionalArray<c10::SymInt>& self_self_sym_blocksize_opt)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (to_sparse_backward(grad, self_layout, self_self_sym_blocksize_opt)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ToSparseCscBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_layout = packed_args.unpack<at::Layout>();
  auto self_self_sym_blocksize_opt = packed_args.unpack<c10::OptionalArray<c10::SymInt>>();
  return ToSparseCscBackward0_apply_functional(variable_list(grads), needs_input_grad, self_layout, self_self_sym_blocksize_opt);
#endif
}

variable_list ToSparseCscBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ToSparseCscBackward0_apply_functional(std::move(grads), needs_input_grad, self_layout, self_self_sym_blocksize_opt);
}

void ToSparseCscBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_layout);
    args.collect(self_self_sym_blocksize_opt);
}
variable_list ToSparseCscBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_layout);
  saved.before(self_self_sym_blocksize_opt);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Layout>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::OptionalArray<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ToSparseCscBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_layout);
  packed_args.pack(self_self_sym_blocksize_opt);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_layout);
  saved.after(self_self_sym_blocksize_opt);
  return output_result;
#endif
}

static variable_list ToSparseBsrBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, at::Layout& self_layout, c10::OptionalArray<c10::SymInt>& self_self_sym_blocksize_opt)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (to_sparse_backward(grad, self_layout, self_self_sym_blocksize_opt)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ToSparseBsrBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_layout = packed_args.unpack<at::Layout>();
  auto self_self_sym_blocksize_opt = packed_args.unpack<c10::OptionalArray<c10::SymInt>>();
  return ToSparseBsrBackward0_apply_functional(variable_list(grads), needs_input_grad, self_layout, self_self_sym_blocksize_opt);
#endif
}

variable_list ToSparseBsrBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ToSparseBsrBackward0_apply_functional(std::move(grads), needs_input_grad, self_layout, self_self_sym_blocksize_opt);
}

void ToSparseBsrBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_layout);
    args.collect(self_self_sym_blocksize_opt);
}
variable_list ToSparseBsrBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_layout);
  saved.before(self_self_sym_blocksize_opt);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Layout>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::OptionalArray<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ToSparseBsrBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_layout);
  packed_args.pack(self_self_sym_blocksize_opt);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_layout);
  saved.after(self_self_sym_blocksize_opt);
  return output_result;
#endif
}

static variable_list ToSparseBscBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, at::Layout& self_layout, c10::OptionalArray<c10::SymInt>& self_self_sym_blocksize_opt)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (to_sparse_backward(grad, self_layout, self_self_sym_blocksize_opt)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ToSparseBscBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_layout = packed_args.unpack<at::Layout>();
  auto self_self_sym_blocksize_opt = packed_args.unpack<c10::OptionalArray<c10::SymInt>>();
  return ToSparseBscBackward0_apply_functional(variable_list(grads), needs_input_grad, self_layout, self_self_sym_blocksize_opt);
#endif
}

variable_list ToSparseBscBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ToSparseBscBackward0_apply_functional(std::move(grads), needs_input_grad, self_layout, self_self_sym_blocksize_opt);
}

void ToSparseBscBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_layout);
    args.collect(self_self_sym_blocksize_opt);
}
variable_list ToSparseBscBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_layout);
  saved.before(self_self_sym_blocksize_opt);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Layout>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::OptionalArray<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ToSparseBscBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_layout);
  packed_args.pack(self_self_sym_blocksize_opt);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_layout);
  saved.after(self_self_sym_blocksize_opt);
  return output_result;
#endif
}

static variable_list ToMkldnnBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (to_mkldnn_backward(grad, self)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ToMkldnnBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  return ToMkldnnBackward0_apply_functional(variable_list(grads), needs_input_grad, self);
#endif
}

variable_list ToMkldnnBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ToMkldnnBackward0_apply_functional(std::move(grads), needs_input_grad, self);
}

void ToMkldnnBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list ToMkldnnBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ToMkldnnBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list UnfoldBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dimension, std::vector<c10::SymInt>& self_sym_sizes, int64_t& size, int64_t& step)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (unfold_backward_symint(grad, self_sym_sizes, dimension, size, step)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list UnfoldBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dimension = packed_args.unpack<int64_t>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  auto size = packed_args.unpack<int64_t>();
  auto step = packed_args.unpack<int64_t>();
  return UnfoldBackward0_apply_functional(variable_list(grads), needs_input_grad, dimension, self_sym_sizes, size, step);
#endif
}

variable_list UnfoldBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return UnfoldBackward0_apply_functional(std::move(grads), needs_input_grad, dimension, self_sym_sizes, size, step);
}

void UnfoldBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dimension);
    args.collect(self_sym_sizes);
    args.collect(size);
    args.collect(step);
}
variable_list UnfoldBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dimension);
  saved.before(self_sym_sizes);
  saved.before(size);
  saved.before(step);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), UnfoldBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dimension);
  packed_args.pack(self_sym_sizes);
  packed_args.pack(size);
  packed_args.pack(step);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dimension);
  saved.after(self_sym_sizes);
  saved.after(size);
  saved.after(step);
  return output_result;
#endif
}

static variable_list UnfoldBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim, int64_t& size, int64_t& step)
{
  IndexRangeGenerator gen;
  auto grad_in_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_in*/0]) {
    auto grad_result = any_grad_defined ? (grad.unfold(dim, size, step)) : Tensor();
    copy_range(grad_inputs, grad_in_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list UnfoldBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  auto size = packed_args.unpack<int64_t>();
  auto step = packed_args.unpack<int64_t>();
  return UnfoldBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, size, step);
#endif
}

variable_list UnfoldBackwardBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto grad_in_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ grad_in_ix }),
  };
  return UnfoldBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, dim, size, step);
}

void UnfoldBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(size);
    args.collect(step);
}
variable_list UnfoldBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(size);
  saved.before(step);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), UnfoldBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto grad_in_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ grad_in_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(size);
  packed_args.pack(step);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(size);
  saved.after(step);
  return output_result;
#endif
}

static variable_list UniformBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (zeros_like(grad)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list UniformBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return UniformBackward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list UniformBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return UniformBackward0_apply_functional(std::move(grads), needs_input_grad);
}

void UniformBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list UniformBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), UniformBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list UniqueBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = not_implemented("_unique");
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list UniqueBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return UniqueBackward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list UniqueBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return UniqueBackward0_apply_functional(std::move(grads), needs_input_grad);
}

void UniqueBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list UniqueBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), UniqueBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list UniqueDimBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = not_implemented("unique_dim");
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list UniqueDimBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return UniqueDimBackward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list UniqueDimBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return UniqueDimBackward0_apply_functional(std::move(grads), needs_input_grad);
}

void UniqueDimBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list UniqueDimBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), UniqueDimBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list UniqueConsecutiveBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = not_implemented("unique_consecutive");
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list UniqueConsecutiveBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return UniqueConsecutiveBackward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list UniqueConsecutiveBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return UniqueConsecutiveBackward0_apply_functional(std::move(grads), needs_input_grad);
}

void UniqueConsecutiveBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list UniqueConsecutiveBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), UniqueConsecutiveBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list UniqueDimConsecutiveBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = not_implemented("unique_dim_consecutive");
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list UniqueDimConsecutiveBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return UniqueDimConsecutiveBackward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list UniqueDimConsecutiveBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return UniqueDimConsecutiveBackward0_apply_functional(std::move(grads), needs_input_grad);
}

void UniqueDimConsecutiveBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list UniqueDimConsecutiveBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), UniqueDimConsecutiveBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list Unique2Backward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = not_implemented("_unique2");
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list Unique2Backward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return Unique2Backward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list Unique2Backward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return Unique2Backward0_apply_functional(std::move(grads), needs_input_grad);
}

void Unique2Backward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list Unique2Backward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), Unique2Backward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list UnsafeViewBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<c10::SymInt>& self_sym_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.reshape_symint(self_sym_sizes)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list UnsafeViewBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return UnsafeViewBackward0_apply_functional(variable_list(grads), needs_input_grad, self_sym_sizes);
#endif
}

variable_list UnsafeViewBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return UnsafeViewBackward0_apply_functional(std::move(grads), needs_input_grad, self_sym_sizes);
}

void UnsafeViewBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_sym_sizes);
}
variable_list UnsafeViewBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), UnsafeViewBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_sym_sizes);
  return output_result;
#endif
}

static variable_list LiftBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list LiftBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return LiftBackward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list LiftBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return LiftBackward0_apply_functional(std::move(grads), needs_input_grad);
}

void LiftBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list LiftBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), LiftBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list LiftFreshBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list LiftFreshBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return LiftFreshBackward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list LiftFreshBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return LiftFreshBackward0_apply_functional(std::move(grads), needs_input_grad);
}

void LiftFreshBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list LiftFreshBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), LiftFreshBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list UnsqueezeBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.squeeze(dim)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list UnsqueezeBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  return UnsqueezeBackward0_apply_functional(variable_list(grads), needs_input_grad, dim);
#endif
}

variable_list UnsqueezeBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return UnsqueezeBackward0_apply_functional(std::move(grads), needs_input_grad, dim);
}

void UnsqueezeBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
}
variable_list UnsqueezeBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), UnsqueezeBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  return output_result;
#endif
}

static variable_list UnsqueezeBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.squeeze(dim)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list UnsqueezeBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  return UnsqueezeBackward1_apply_functional(variable_list(grads), needs_input_grad, dim);
#endif
}

variable_list UnsqueezeBackward1::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return UnsqueezeBackward1_apply_functional(std::move(grads), needs_input_grad, dim);
}

void UnsqueezeBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
}
variable_list UnsqueezeBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), UnsqueezeBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  return output_result;
#endif
}

static variable_list VarBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, ::std::optional<at::Scalar>& correction, c10::OptionalArray<int64_t>& dim, bool& keepdim, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (var_backward(grad, self, dim, correction, keepdim)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list VarBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto correction = packed_args.unpack<::std::optional<at::Scalar>>();
  auto dim = packed_args.unpack<c10::OptionalArray<int64_t>>();
  auto keepdim = packed_args.unpack<bool>();
  auto self = packed_args.unpack<Tensor>();
  return VarBackward0_apply_functional(variable_list(grads), needs_input_grad, correction, dim, keepdim, self);
#endif
}

variable_list VarBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return VarBackward0_apply_functional(std::move(grads), needs_input_grad, correction, dim, keepdim, self);
}

void VarBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(correction);
    args.collect(dim);
    args.collect(keepdim);
    args.collect(self_, false);
}
variable_list VarBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(correction);
  saved.before(dim);
  saved.before(keepdim);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<at::Scalar>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::OptionalArray<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), VarBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(correction);
  packed_args.pack(dim);
  packed_args.pack(keepdim);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(correction);
  saved.after(dim);
  saved.after(keepdim);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list VarMeanBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, ::std::optional<at::Scalar>& correction, c10::OptionalArray<int64_t>& dim, bool& keepdim, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (var_mean_backward(grads[0], grads[1], self, dim, correction, keepdim)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list VarMeanBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto correction = packed_args.unpack<::std::optional<at::Scalar>>();
  auto dim = packed_args.unpack<c10::OptionalArray<int64_t>>();
  auto keepdim = packed_args.unpack<bool>();
  auto self = packed_args.unpack<Tensor>();
  return VarMeanBackward0_apply_functional(variable_list(grads), needs_input_grad, correction, dim, keepdim, self);
#endif
}

variable_list VarMeanBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return VarMeanBackward0_apply_functional(std::move(grads), needs_input_grad, correction, dim, keepdim, self);
}

void VarMeanBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(correction);
    args.collect(dim);
    args.collect(keepdim);
    args.collect(self_, false);
}
variable_list VarMeanBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(correction);
  saved.before(dim);
  saved.before(keepdim);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<at::Scalar>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::OptionalArray<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), VarMeanBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(correction);
  packed_args.pack(dim);
  packed_args.pack(keepdim);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(correction);
  saved.after(dim);
  saved.after(keepdim);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list ViewBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<c10::SymInt>& self_sym_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.reshape_symint(self_sym_sizes)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ViewBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return ViewBackward0_apply_functional(variable_list(grads), needs_input_grad, self_sym_sizes);
#endif
}

variable_list ViewBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ViewBackward0_apply_functional(std::move(grads), needs_input_grad, self_sym_sizes);
}

void ViewBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_sym_sizes);
}
variable_list ViewBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ViewBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_sym_sizes);
  return output_result;
#endif
}

static variable_list ViewBackwardAutogradNestedTensor0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.reshape_as(self)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ViewBackwardAutogradNestedTensor0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  return ViewBackwardAutogradNestedTensor0_apply_functional(variable_list(grads), needs_input_grad, self);
#endif
}

variable_list ViewBackwardAutogradNestedTensor0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ViewBackwardAutogradNestedTensor0_apply_functional(std::move(grads), needs_input_grad, self);
}

void ViewBackwardAutogradNestedTensor0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list ViewBackwardAutogradNestedTensor0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ViewBackwardAutogradNestedTensor0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list ViewAsRealBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (at::view_as_complex(grad.contiguous())) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ViewAsRealBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return ViewAsRealBackward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list ViewAsRealBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ViewAsRealBackward0_apply_functional(std::move(grads), needs_input_grad);
}

void ViewAsRealBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list ViewAsRealBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ViewAsRealBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list ViewAsComplexBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (at::view_as_real(grad.contiguous().resolve_conj())) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ViewAsComplexBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return ViewAsComplexBackward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list ViewAsComplexBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ViewAsComplexBackward0_apply_functional(std::move(grads), needs_input_grad);
}

void ViewAsComplexBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list ViewAsComplexBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ViewAsComplexBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list WhereBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& condition)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*other*/1]) {
    auto grad_result = any_grad_defined ? (where(condition, 0, grad)) : Tensor();
    copy_range(grad_inputs, other_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (where(condition, grad, 0)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list WhereBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto condition = packed_args.unpack<Tensor>();
  return WhereBackward0_apply_functional(variable_list(grads), needs_input_grad, condition);
#endif
}

variable_list WhereBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto condition = condition_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  return WhereBackward0_apply_functional(std::move(grads), needs_input_grad, condition);
}

void WhereBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(condition_, false);
}
variable_list WhereBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(condition_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), WhereBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto condition = condition_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(condition);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(condition_);
  return output_result;
#endif
}

static variable_list WeightNormInterfaceBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, int64_t& dim, Tensor& g, Tensor& v, Tensor& result1)
{
  IndexRangeGenerator gen;
  auto v_ix = gen.range(1);
  auto g_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1]) {
  
    auto grad_result = grad.defined() ? (GradMode::is_enabled() ? _weight_norm_differentiable_backward(grad.contiguous(), v, g, result1, dim) : _weight_norm_interface_backward(grad.contiguous(), v, g, result1, dim)) : std::tuple<Tensor, Tensor>();
      if (needs_input_grad[/*v*/0]) {
        copy_range(grad_inputs, v_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*g*/1]) {
        copy_range(grad_inputs, g_ix, std::get<1>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list WeightNormInterfaceBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto dim = packed_args.unpack<int64_t>();
  auto g = packed_args.unpack<Tensor>();
  auto v = packed_args.unpack<Tensor>();
  auto result1 = packed_args.unpack<Tensor>();
  return WeightNormInterfaceBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, g, v, result1);
#endif
}

variable_list WeightNormInterfaceBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto g = g_.unpack();
  auto v = v_.unpack();
  auto result1 = result1_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto v_ix = gen.range(1);
  auto g_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ v_ix }),
    task_should_compute_output({ g_ix }),
  };
  return WeightNormInterfaceBackward0_apply_functional(std::move(grads), needs_input_grad, dim, g, v, result1);
}

void WeightNormInterfaceBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(g_, false);
    args.collect(v_, false);
    args.collect(result1_, true);
}
variable_list WeightNormInterfaceBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(g_);
  saved.before(v_);
  saved.before(result1_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), WeightNormInterfaceBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto g = g_.unpack();
  auto v = v_.unpack();
  auto result1 = result1_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto v_ix = gen.range(1);
  auto g_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ v_ix }),
    task_should_compute_output({ g_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(g);
  packed_args.pack(v);
  packed_args.pack(result1);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(g_);
  saved.after(v_);
  saved.after(result1_);
  return output_result;
#endif
}

static variable_list ZeroBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (zeros_like(grad)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ZeroBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return ZeroBackward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list ZeroBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ZeroBackward0_apply_functional(std::move(grads), needs_input_grad);
}

void ZeroBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list ZeroBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ZeroBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list SparseMaskBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& mask, at::Layout& self_layout)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (sparse_mask_backward(grad, mask, self_layout)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SparseMaskBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto mask = packed_args.unpack<Tensor>();
  auto self_layout = packed_args.unpack<at::Layout>();
  return SparseMaskBackward0_apply_functional(variable_list(grads), needs_input_grad, mask, self_layout);
#endif
}

variable_list SparseMaskBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto mask = mask_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SparseMaskBackward0_apply_functional(std::move(grads), needs_input_grad, mask, self_layout);
}

void SparseMaskBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(mask_, false);
    args.collect(self_layout);
}
variable_list SparseMaskBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(mask_);
  saved.before(self_layout);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Layout>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SparseMaskBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto mask = mask_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(mask);
  packed_args.pack(self_layout);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(mask_);
  saved.after(self_layout);
  return output_result;
#endif
}

static variable_list SparseCooTensorWithDimsAndTensorsBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& result)
{
  IndexRangeGenerator gen;
  auto values_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*values*/0]) {
    auto grad_result = any_grad_defined ? (grad.sparse_mask(result)._values()) : Tensor();
    copy_range(grad_inputs, values_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SparseCooTensorWithDimsAndTensorsBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto result = packed_args.unpack<Tensor>();
  return SparseCooTensorWithDimsAndTensorsBackward0_apply_functional(variable_list(grads), needs_input_grad, result);
#endif
}

variable_list SparseCooTensorWithDimsAndTensorsBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto values_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ values_ix }),
  };
  return SparseCooTensorWithDimsAndTensorsBackward0_apply_functional(std::move(grads), needs_input_grad, result);
}

void SparseCooTensorWithDimsAndTensorsBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(result_, true);
}
variable_list SparseCooTensorWithDimsAndTensorsBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SparseCooTensorWithDimsAndTensorsBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto values_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ values_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(result_);
  return output_result;
#endif
}

static variable_list SparseCompressedTensorBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& values, Tensor& result)
{
  IndexRangeGenerator gen;
  auto values_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*values*/0]) {
    auto grad_result = any_grad_defined ? (grad.to_dense().sparse_mask(result).values()) : Tensor();
    copy_range(grad_inputs, values_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SparseCompressedTensorBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto values = packed_args.unpack<Tensor>();
  auto result = packed_args.unpack<Tensor>();
  return SparseCompressedTensorBackward0_apply_functional(variable_list(grads), needs_input_grad, values, result);
#endif
}

variable_list SparseCompressedTensorBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto values = values_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto values_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ values_ix }),
  };
  return SparseCompressedTensorBackward0_apply_functional(std::move(grads), needs_input_grad, values, result);
}

void SparseCompressedTensorBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(values_, false);
    args.collect(result_, true);
}
variable_list SparseCompressedTensorBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(values_);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SparseCompressedTensorBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto values = values_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto values_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ values_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(values);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(values_);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list SparseSumBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<int64_t>& dim, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (at::_sparse_sum_backward(grad, self, dim)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SparseSumBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<std::vector<int64_t>>();
  auto self = packed_args.unpack<Tensor>();
  return SparseSumBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, self);
#endif
}

variable_list SparseSumBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SparseSumBackward0_apply_functional(std::move(grads), needs_input_grad, dim, self);
}

void SparseSumBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(self_, false);
}
variable_list SparseSumBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SparseSumBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list StandardGammaBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad * _standard_gamma_grad(self, result)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list StandardGammaBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  auto result = packed_args.unpack<Tensor>();
  return StandardGammaBackward0_apply_functional(variable_list(grads), needs_input_grad, self, result);
#endif
}

variable_list StandardGammaBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return StandardGammaBackward0_apply_functional(std::move(grads), needs_input_grad, self, result);
}

void StandardGammaBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
    args.collect(result_, true);
}
variable_list StandardGammaBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), StandardGammaBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list StandardGammaGradBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = not_implemented("_standard_gamma_grad");
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list StandardGammaGradBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return StandardGammaGradBackward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list StandardGammaGradBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return StandardGammaGradBackward0_apply_functional(std::move(grads), needs_input_grad);
}

void StandardGammaGradBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list StandardGammaGradBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), StandardGammaGradBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list ValuesBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (values_backward(grad, self)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ValuesBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  return ValuesBackward0_apply_functional(variable_list(grads), needs_input_grad, self);
#endif
}

variable_list ValuesBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ValuesBackward0_apply_functional(std::move(grads), needs_input_grad, self);
}

void ValuesBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list ValuesBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ValuesBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list ValuesBackwardAutogradNestedTensor0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (at::_nested_view_from_buffer(grad.contiguous(), self._nested_tensor_size(), self._nested_tensor_strides(), self._nested_tensor_storage_offsets())) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ValuesBackwardAutogradNestedTensor0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  return ValuesBackwardAutogradNestedTensor0_apply_functional(variable_list(grads), needs_input_grad, self);
#endif
}

variable_list ValuesBackwardAutogradNestedTensor0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ValuesBackwardAutogradNestedTensor0_apply_functional(std::move(grads), needs_input_grad, self);
}

void ValuesBackwardAutogradNestedTensor0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list ValuesBackwardAutogradNestedTensor0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ValuesBackwardAutogradNestedTensor0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list TrilinearBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, std::vector<int64_t>& expand1, std::vector<int64_t>& expand2, std::vector<int64_t>& expand3, Tensor& i1, Tensor& i2, Tensor& i3, std::vector<int64_t>& sumdim)
{
  IndexRangeGenerator gen;
  auto i1_ix = gen.range(1);
  auto i2_ix = gen.range(1);
  auto i3_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1] || needs_input_grad[2]) {
      auto grad_input_mask = std::array<bool, 3>{
        needs_input_grad[0],
        needs_input_grad[1],
        needs_input_grad[2],
      };
    auto grad_result = _trilinear_backward(grad, wrap_opt_if(i1, grad_input_mask[1] || grad_input_mask[2]), wrap_opt_if(i2, grad_input_mask[0] || grad_input_mask[2]), wrap_opt_if(i3, grad_input_mask[0] || grad_input_mask[1]), expand1, expand2, expand3, sumdim, grad_input_mask);
      if (needs_input_grad[/*i1*/0]) {
        copy_range(grad_inputs, i1_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*i2*/1]) {
        copy_range(grad_inputs, i2_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*i3*/2]) {
        copy_range(grad_inputs, i3_ix, std::get<2>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list TrilinearBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto expand1 = packed_args.unpack<std::vector<int64_t>>();
  auto expand2 = packed_args.unpack<std::vector<int64_t>>();
  auto expand3 = packed_args.unpack<std::vector<int64_t>>();
  auto i1 = packed_args.unpack<Tensor>();
  auto i2 = packed_args.unpack<Tensor>();
  auto i3 = packed_args.unpack<Tensor>();
  auto sumdim = packed_args.unpack<std::vector<int64_t>>();
  return TrilinearBackward0_apply_functional(variable_list(grads), needs_input_grad, expand1, expand2, expand3, i1, i2, i3, sumdim);
#endif
}

variable_list TrilinearBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto i1 = i1_.unpack();
  auto i2 = i2_.unpack();
  auto i3 = i3_.unpack();
  IndexRangeGenerator gen;
  auto i1_ix = gen.range(1);
  auto i2_ix = gen.range(1);
  auto i3_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ i1_ix }),
    task_should_compute_output({ i2_ix }),
    task_should_compute_output({ i3_ix }),
  };
  return TrilinearBackward0_apply_functional(std::move(grads), needs_input_grad, expand1, expand2, expand3, i1, i2, i3, sumdim);
}

void TrilinearBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(expand1);
    args.collect(expand2);
    args.collect(expand3);
    args.collect(i1_, false);
    args.collect(i2_, false);
    args.collect(i3_, false);
    args.collect(sumdim);
}
variable_list TrilinearBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(expand1);
  saved.before(expand2);
  saved.before(expand3);
  saved.before(i1_);
  saved.before(i2_);
  saved.before(i3_);
  saved.before(sumdim);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), TrilinearBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto i1 = i1_.unpack();
  auto i2 = i2_.unpack();
  auto i3 = i3_.unpack();
  IndexRangeGenerator gen;
  auto i1_ix = gen.range(1);
  auto i2_ix = gen.range(1);
  auto i3_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ i1_ix }),
    task_should_compute_output({ i2_ix }),
    task_should_compute_output({ i3_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(expand1);
  packed_args.pack(expand2);
  packed_args.pack(expand3);
  packed_args.pack(i1);
  packed_args.pack(i2);
  packed_args.pack(i3);
  packed_args.pack(sumdim);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(expand1);
  saved.after(expand2);
  saved.after(expand3);
  saved.after(i1_);
  saved.after(i2_);
  saved.after(i3_);
  saved.after(sumdim);
  return output_result;
#endif
}

static variable_list ConstantPadNdBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<c10::SymInt>& pad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (constant_pad_nd_backward(grad, pad)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ConstantPadNdBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto pad = packed_args.unpack<std::vector<c10::SymInt>>();
  return ConstantPadNdBackward0_apply_functional(variable_list(grads), needs_input_grad, pad);
#endif
}

variable_list ConstantPadNdBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ConstantPadNdBackward0_apply_functional(std::move(grads), needs_input_grad, pad);
}

void ConstantPadNdBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(pad);
}
variable_list ConstantPadNdBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(pad);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ConstantPadNdBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(pad);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(pad);
  return output_result;
#endif
}

static variable_list BinaryCrossEntropyBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, int64_t& reduction, Tensor& self, Tensor& target, Tensor& weight)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto target_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (binary_cross_entropy_backward(grad, self, target, weight, reduction)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  if (needs_input_grad[/*target*/1]) {
    auto grad_result = any_grad_defined ? (binary_cross_entropy_target_backward(grad, self, target, weight, reduction)) : Tensor();
    copy_range(grad_inputs, target_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list BinaryCrossEntropyBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto reduction = packed_args.unpack<int64_t>();
  auto self = packed_args.unpack<Tensor>();
  auto target = packed_args.unpack<Tensor>();
  auto weight = packed_args.unpack<Tensor>();
  return BinaryCrossEntropyBackward0_apply_functional(variable_list(grads), needs_input_grad, reduction, self, target, weight);
#endif
}

variable_list BinaryCrossEntropyBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto target = target_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto target_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ target_ix }),
  };
  return BinaryCrossEntropyBackward0_apply_functional(std::move(grads), needs_input_grad, reduction, self, target, weight);
}

void BinaryCrossEntropyBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(reduction);
    args.collect(self_, false);
    args.collect(target_, false);
    args.collect(weight_, false);
}
variable_list BinaryCrossEntropyBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(reduction);
  saved.before(self_);
  saved.before(target_);
  saved.before(weight_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), BinaryCrossEntropyBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto target = target_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto target_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ target_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(reduction);
  packed_args.pack(self);
  packed_args.pack(target);
  packed_args.pack(weight);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(reduction);
  saved.after(self_);
  saved.after(target_);
  saved.after(weight_);
  return output_result;
#endif
}

static variable_list BinaryCrossEntropyBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, Tensor& grad_output, int64_t& reduction, Tensor& self, Tensor& target, Tensor& weight)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto target_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (binary_cross_entropy_double_backward_grad_output(grad, self, target, weight, reduction)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  if (needs_input_grad[/*self*/1]) {
    auto grad_result = any_grad_defined ? (binary_cross_entropy_double_backward(grad_output, grad, self, target, weight, reduction)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  if (needs_input_grad[/*target*/2]) {
    auto grad_result = any_grad_defined ? (binary_cross_entropy_double_backward_target(grad, grad_output, self, target, weight, reduction)) : Tensor();
    copy_range(grad_inputs, target_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list BinaryCrossEntropyBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto grad_output = packed_args.unpack<Tensor>();
  auto reduction = packed_args.unpack<int64_t>();
  auto self = packed_args.unpack<Tensor>();
  auto target = packed_args.unpack<Tensor>();
  auto weight = packed_args.unpack<Tensor>();
  return BinaryCrossEntropyBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, grad_output, reduction, self, target, weight);
#endif
}

variable_list BinaryCrossEntropyBackwardBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto grad_output = grad_output_.unpack();
  auto self = self_.unpack();
  auto target = target_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto target_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ target_ix }),
  };
  return BinaryCrossEntropyBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, grad_output, reduction, self, target, weight);
}

void BinaryCrossEntropyBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(grad_output_, false);
    args.collect(reduction);
    args.collect(self_, false);
    args.collect(target_, false);
    args.collect(weight_, false);
}
variable_list BinaryCrossEntropyBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(grad_output_);
  saved.before(reduction);
  saved.before(self_);
  saved.before(target_);
  saved.before(weight_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), BinaryCrossEntropyBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto grad_output = grad_output_.unpack();
  auto self = self_.unpack();
  auto target = target_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto target_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ target_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(grad_output);
  packed_args.pack(reduction);
  packed_args.pack(self);
  packed_args.pack(target);
  packed_args.pack(weight);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(grad_output_);
  saved.after(reduction);
  saved.after(self_);
  saved.after(target_);
  saved.after(weight_);
  return output_result;
#endif
}

static variable_list BinaryCrossEntropyWithLogitsBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& pos_weight, int64_t& reduction, Tensor& self, Tensor& target, Tensor& weight)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto target_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (binary_cross_entropy_with_logits_backward(grad, self, target, weight, pos_weight, reduction)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  if (needs_input_grad[/*target*/1]) {
    auto grad_result = any_grad_defined ? (binary_cross_entropy_with_logits_target_backward(grad, self, target, weight, pos_weight, reduction)) : Tensor();
    copy_range(grad_inputs, target_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list BinaryCrossEntropyWithLogitsBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto pos_weight = packed_args.unpack<Tensor>();
  auto reduction = packed_args.unpack<int64_t>();
  auto self = packed_args.unpack<Tensor>();
  auto target = packed_args.unpack<Tensor>();
  auto weight = packed_args.unpack<Tensor>();
  return BinaryCrossEntropyWithLogitsBackward0_apply_functional(variable_list(grads), needs_input_grad, pos_weight, reduction, self, target, weight);
#endif
}

variable_list BinaryCrossEntropyWithLogitsBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto pos_weight = pos_weight_.unpack();
  auto self = self_.unpack();
  auto target = target_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto target_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ target_ix }),
  };
  return BinaryCrossEntropyWithLogitsBackward0_apply_functional(std::move(grads), needs_input_grad, pos_weight, reduction, self, target, weight);
}

void BinaryCrossEntropyWithLogitsBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(pos_weight_, false);
    args.collect(reduction);
    args.collect(self_, false);
    args.collect(target_, false);
    args.collect(weight_, false);
}
variable_list BinaryCrossEntropyWithLogitsBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(pos_weight_);
  saved.before(reduction);
  saved.before(self_);
  saved.before(target_);
  saved.before(weight_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), BinaryCrossEntropyWithLogitsBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto pos_weight = pos_weight_.unpack();
  auto self = self_.unpack();
  auto target = target_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto target_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ target_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(pos_weight);
  packed_args.pack(reduction);
  packed_args.pack(self);
  packed_args.pack(target);
  packed_args.pack(weight);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(pos_weight_);
  saved.after(reduction);
  saved.after(self_);
  saved.after(target_);
  saved.after(weight_);
  return output_result;
#endif
}

static variable_list EmbeddingBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& indices, c10::SymInt& padding_idx, bool& scale_grad_by_freq, bool& sparse, c10::SymInt& weight_sym_argsize_0)
{
  IndexRangeGenerator gen;
  auto weight_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*weight*/0]) {
    auto grad_result = any_grad_defined ? (embedding_backward_symint(grad, indices, weight_sym_argsize_0, padding_idx, scale_grad_by_freq, sparse)) : Tensor();
    copy_range(grad_inputs, weight_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list EmbeddingBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto indices = packed_args.unpack<Tensor>();
  auto padding_idx = packed_args.unpack<c10::SymInt>();
  auto scale_grad_by_freq = packed_args.unpack<bool>();
  auto sparse = packed_args.unpack<bool>();
  auto weight_sym_argsize_0 = packed_args.unpack<c10::SymInt>();
  return EmbeddingBackward0_apply_functional(variable_list(grads), needs_input_grad, indices, padding_idx, scale_grad_by_freq, sparse, weight_sym_argsize_0);
#endif
}

variable_list EmbeddingBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto indices = indices_.unpack();
  IndexRangeGenerator gen;
  auto weight_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ weight_ix }),
  };
  return EmbeddingBackward0_apply_functional(std::move(grads), needs_input_grad, indices, padding_idx, scale_grad_by_freq, sparse, weight_sym_argsize_0);
}

void EmbeddingBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(indices_, false);
    args.collect(padding_idx);
    args.collect(scale_grad_by_freq);
    args.collect(sparse);
    args.collect(weight_sym_argsize_0);
}
variable_list EmbeddingBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(indices_);
  saved.before(padding_idx);
  saved.before(scale_grad_by_freq);
  saved.before(sparse);
  saved.before(weight_sym_argsize_0);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), EmbeddingBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto indices = indices_.unpack();
  IndexRangeGenerator gen;
  auto weight_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ weight_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(indices);
  packed_args.pack(padding_idx);
  packed_args.pack(scale_grad_by_freq);
  packed_args.pack(sparse);
  packed_args.pack(weight_sym_argsize_0);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(indices_);
  saved.after(padding_idx);
  saved.after(scale_grad_by_freq);
  saved.after(sparse);
  saved.after(weight_sym_argsize_0);
  return output_result;
#endif
}

static variable_list EmbeddingDenseBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& indices, c10::SymInt& padding_idx)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (embedding_dense_double_backward_symint(grad, indices, padding_idx)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list EmbeddingDenseBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto indices = packed_args.unpack<Tensor>();
  auto padding_idx = packed_args.unpack<c10::SymInt>();
  return EmbeddingDenseBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, indices, padding_idx);
#endif
}

variable_list EmbeddingDenseBackwardBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto indices = indices_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ grad_output_ix }),
  };
  return EmbeddingDenseBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, indices, padding_idx);
}

void EmbeddingDenseBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(indices_, false);
    args.collect(padding_idx);
}
variable_list EmbeddingDenseBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(indices_);
  saved.before(padding_idx);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), EmbeddingDenseBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto indices = indices_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ grad_output_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(indices);
  packed_args.pack(padding_idx);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(indices_);
  saved.after(padding_idx);
  return output_result;
#endif
}

static variable_list EmbeddingBagBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& indices, int64_t& mode, Tensor& offsets, int64_t& padding_idx, Tensor& per_sample_weights, bool& scale_grad_by_freq, bool& sparse, Tensor& weight, c10::SymInt& weight_sym_argsize_0, Tensor& result1, Tensor& result2, Tensor& result3)
{
  IndexRangeGenerator gen;
  auto weight_ix = gen.range(1);
  auto per_sample_weights_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*per_sample_weights*/1]) {
    auto grad_result = any_grad_defined ? (_embedding_bag_per_sample_weights_backward(grad, weight, indices, offsets, result1, mode, padding_idx)) : Tensor();
    copy_range(grad_inputs, per_sample_weights_ix, grad_result);
  }
  if (needs_input_grad[/*weight*/0]) {
    auto grad_result = any_grad_defined ? (_embedding_bag_backward_symint(grad, indices, offsets, result1, result2, result3, weight_sym_argsize_0, scale_grad_by_freq, mode, sparse, per_sample_weights, padding_idx)) : Tensor();
    copy_range(grad_inputs, weight_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list EmbeddingBagBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto indices = packed_args.unpack<Tensor>();
  auto mode = packed_args.unpack<int64_t>();
  auto offsets = packed_args.unpack<Tensor>();
  auto padding_idx = packed_args.unpack<int64_t>();
  auto per_sample_weights = packed_args.unpack<Tensor>();
  auto scale_grad_by_freq = packed_args.unpack<bool>();
  auto sparse = packed_args.unpack<bool>();
  auto weight = packed_args.unpack<Tensor>();
  auto weight_sym_argsize_0 = packed_args.unpack<c10::SymInt>();
  auto result1 = packed_args.unpack<Tensor>();
  auto result2 = packed_args.unpack<Tensor>();
  auto result3 = packed_args.unpack<Tensor>();
  return EmbeddingBagBackward0_apply_functional(variable_list(grads), needs_input_grad, indices, mode, offsets, padding_idx, per_sample_weights, scale_grad_by_freq, sparse, weight, weight_sym_argsize_0, result1, result2, result3);
#endif
}

variable_list EmbeddingBagBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto indices = indices_.unpack();
  auto offsets = offsets_.unpack();
  auto per_sample_weights = per_sample_weights_.unpack();
  auto weight = weight_.unpack();
  auto result1 = result1_.unpack(shared_from_this());
  auto result2 = result2_.unpack(shared_from_this());
  auto result3 = result3_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto weight_ix = gen.range(1);
  auto per_sample_weights_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ per_sample_weights_ix }),
  };
  return EmbeddingBagBackward0_apply_functional(std::move(grads), needs_input_grad, indices, mode, offsets, padding_idx, per_sample_weights, scale_grad_by_freq, sparse, weight, weight_sym_argsize_0, result1, result2, result3);
}

void EmbeddingBagBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(indices_, false);
    args.collect(mode);
    args.collect(offsets_, false);
    args.collect(padding_idx);
    args.collect(per_sample_weights_, false);
    args.collect(scale_grad_by_freq);
    args.collect(sparse);
    args.collect(weight_, false);
    args.collect(weight_sym_argsize_0);
    args.collect(result1_, true);
    args.collect(result2_, true);
    args.collect(result3_, true);
}
variable_list EmbeddingBagBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(indices_);
  saved.before(mode);
  saved.before(offsets_);
  saved.before(padding_idx);
  saved.before(per_sample_weights_);
  saved.before(scale_grad_by_freq);
  saved.before(sparse);
  saved.before(weight_);
  saved.before(weight_sym_argsize_0);
  saved.before(result1_);
  saved.before(result2_);
  saved.before(result3_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), EmbeddingBagBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto indices = indices_.unpack();
  auto offsets = offsets_.unpack();
  auto per_sample_weights = per_sample_weights_.unpack();
  auto weight = weight_.unpack();
  auto result1 = result1_.unpack(shared_from_this());
  auto result2 = result2_.unpack(shared_from_this());
  auto result3 = result3_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto weight_ix = gen.range(1);
  auto per_sample_weights_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ per_sample_weights_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(indices);
  packed_args.pack(mode);
  packed_args.pack(offsets);
  packed_args.pack(padding_idx);
  packed_args.pack(per_sample_weights);
  packed_args.pack(scale_grad_by_freq);
  packed_args.pack(sparse);
  packed_args.pack(weight);
  packed_args.pack(weight_sym_argsize_0);
  packed_args.pack(result1);
  packed_args.pack(result2);
  packed_args.pack(result3);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(indices_);
  saved.after(mode);
  saved.after(offsets_);
  saved.after(padding_idx);
  saved.after(per_sample_weights_);
  saved.after(scale_grad_by_freq);
  saved.after(sparse);
  saved.after(weight_);
  saved.after(weight_sym_argsize_0);
  saved.after(result1_);
  saved.after(result2_);
  saved.after(result3_);
  return output_result;
#endif
}

static variable_list EmbeddingBagBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto grad_ix = gen.range(1);
  auto per_sample_weights_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*grad*/0]) {
    auto grad_result = not_implemented("_embedding_bag_backward");
    copy_range(grad_inputs, grad_ix, grad_result);
  }
  if (needs_input_grad[/*per_sample_weights*/1]) {
    auto grad_result = not_implemented("_embedding_bag_backward");
    copy_range(grad_inputs, per_sample_weights_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list EmbeddingBagBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();

  return EmbeddingBagBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list EmbeddingBagBackwardBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto grad_ix = gen.range(1);
  auto per_sample_weights_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_ix }),
    task_should_compute_output({ per_sample_weights_ix }),
  };
  return EmbeddingBagBackwardBackward0_apply_functional(std::move(grads), needs_input_grad);
}

void EmbeddingBagBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list EmbeddingBagBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), EmbeddingBagBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto grad_ix = gen.range(1);
  auto per_sample_weights_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_ix }),
    task_should_compute_output({ per_sample_weights_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list EmbeddingBagDenseBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto grad_ix = gen.range(1);
  auto per_sample_weights_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*grad*/0]) {
    auto grad_result = not_implemented("_embedding_bag_dense_backward");
    copy_range(grad_inputs, grad_ix, grad_result);
  }
  if (needs_input_grad[/*per_sample_weights*/1]) {
    auto grad_result = not_implemented("_embedding_bag_dense_backward");
    copy_range(grad_inputs, per_sample_weights_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list EmbeddingBagDenseBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();

  return EmbeddingBagDenseBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list EmbeddingBagDenseBackwardBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto grad_ix = gen.range(1);
  auto per_sample_weights_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_ix }),
    task_should_compute_output({ per_sample_weights_ix }),
  };
  return EmbeddingBagDenseBackwardBackward0_apply_functional(std::move(grads), needs_input_grad);
}

void EmbeddingBagDenseBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list EmbeddingBagDenseBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), EmbeddingBagDenseBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto grad_ix = gen.range(1);
  auto per_sample_weights_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_ix }),
    task_should_compute_output({ per_sample_weights_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list EmbeddingRenormBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = not_implemented("embedding_renorm");
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list EmbeddingRenormBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return EmbeddingRenormBackward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list EmbeddingRenormBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return EmbeddingRenormBackward0_apply_functional(std::move(grads), needs_input_grad);
}

void EmbeddingRenormBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list EmbeddingRenormBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), EmbeddingRenormBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list MseLossBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, int64_t& reduction, Tensor& self, Tensor& target)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto target_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (mse_loss_backward(grad, self, target, reduction)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  if (needs_input_grad[/*target*/1]) {
    auto grad_result = any_grad_defined ? (mse_loss_backward(grad, target, self, reduction)) : Tensor();
    copy_range(grad_inputs, target_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list MseLossBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto reduction = packed_args.unpack<int64_t>();
  auto self = packed_args.unpack<Tensor>();
  auto target = packed_args.unpack<Tensor>();
  return MseLossBackward0_apply_functional(variable_list(grads), needs_input_grad, reduction, self, target);
#endif
}

variable_list MseLossBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto target = target_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto target_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ target_ix }),
  };
  return MseLossBackward0_apply_functional(std::move(grads), needs_input_grad, reduction, self, target);
}

void MseLossBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(reduction);
    args.collect(self_, false);
    args.collect(target_, false);
}
variable_list MseLossBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(reduction);
  saved.before(self_);
  saved.before(target_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MseLossBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto target = target_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto target_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ target_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(reduction);
  packed_args.pack(self);
  packed_args.pack(target);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(reduction);
  saved.after(self_);
  saved.after(target_);
  return output_result;
#endif
}

static variable_list MultiMarginLossBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, at::Scalar& margin, at::Scalar& p, int64_t& reduction, Tensor& self, Tensor& target, Tensor& weight)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (multi_margin_loss_backward(grad, self, target, p, margin, weight, reduction)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list MultiMarginLossBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto margin = packed_args.unpack<at::Scalar>();
  auto p = packed_args.unpack<at::Scalar>();
  auto reduction = packed_args.unpack<int64_t>();
  auto self = packed_args.unpack<Tensor>();
  auto target = packed_args.unpack<Tensor>();
  auto weight = packed_args.unpack<Tensor>();
  return MultiMarginLossBackward0_apply_functional(variable_list(grads), needs_input_grad, margin, p, reduction, self, target, weight);
#endif
}

variable_list MultiMarginLossBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto target = target_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return MultiMarginLossBackward0_apply_functional(std::move(grads), needs_input_grad, margin, p, reduction, self, target, weight);
}

void MultiMarginLossBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(margin);
    args.collect(p);
    args.collect(reduction);
    args.collect(self_, false);
    args.collect(target_, false);
    args.collect(weight_, false);
}
variable_list MultiMarginLossBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(margin);
  saved.before(p);
  saved.before(reduction);
  saved.before(self_);
  saved.before(target_);
  saved.before(weight_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MultiMarginLossBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto target = target_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(margin);
  packed_args.pack(p);
  packed_args.pack(reduction);
  packed_args.pack(self);
  packed_args.pack(target);
  packed_args.pack(weight);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(margin);
  saved.after(p);
  saved.after(reduction);
  saved.after(self_);
  saved.after(target_);
  saved.after(weight_);
  return output_result;
#endif
}

static variable_list MultilabelMarginLossBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& reduction, Tensor& self, Tensor& target, Tensor& is_target)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (multilabel_margin_loss_backward(grad, self, target, reduction, is_target)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list MultilabelMarginLossBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto reduction = packed_args.unpack<int64_t>();
  auto self = packed_args.unpack<Tensor>();
  auto target = packed_args.unpack<Tensor>();
  auto is_target = packed_args.unpack<Tensor>();
  return MultilabelMarginLossBackward0_apply_functional(variable_list(grads), needs_input_grad, reduction, self, target, is_target);
#endif
}

variable_list MultilabelMarginLossBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto target = target_.unpack();
  auto is_target = is_target_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return MultilabelMarginLossBackward0_apply_functional(std::move(grads), needs_input_grad, reduction, self, target, is_target);
}

void MultilabelMarginLossBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(reduction);
    args.collect(self_, false);
    args.collect(target_, false);
    args.collect(is_target_, true);
}
variable_list MultilabelMarginLossBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(reduction);
  saved.before(self_);
  saved.before(target_);
  saved.before(is_target_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MultilabelMarginLossBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto target = target_.unpack();
  auto is_target = is_target_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(reduction);
  packed_args.pack(self);
  packed_args.pack(target);
  packed_args.pack(is_target);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(reduction);
  saved.after(self_);
  saved.after(target_);
  saved.after(is_target_);
  return output_result;
#endif
}

static variable_list NllLossBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, c10::SymInt& ignore_index, int64_t& reduction, Tensor& self, Tensor& target, Tensor& weight, Tensor& total_weight)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (nll_loss_backward_symint(grad, self, target, weight, reduction, ignore_index, total_weight)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list NllLossBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto ignore_index = packed_args.unpack<c10::SymInt>();
  auto reduction = packed_args.unpack<int64_t>();
  auto self = packed_args.unpack<Tensor>();
  auto target = packed_args.unpack<Tensor>();
  auto weight = packed_args.unpack<Tensor>();
  auto total_weight = packed_args.unpack<Tensor>();
  return NllLossBackward0_apply_functional(variable_list(grads), needs_input_grad, ignore_index, reduction, self, target, weight, total_weight);
#endif
}

variable_list NllLossBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto target = target_.unpack();
  auto weight = weight_.unpack();
  auto total_weight = total_weight_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return NllLossBackward0_apply_functional(std::move(grads), needs_input_grad, ignore_index, reduction, self, target, weight, total_weight);
}

void NllLossBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(ignore_index);
    args.collect(reduction);
    args.collect(self_, false);
    args.collect(target_, false);
    args.collect(weight_, false);
    args.collect(total_weight_, true);
}
variable_list NllLossBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(ignore_index);
  saved.before(reduction);
  saved.before(self_);
  saved.before(target_);
  saved.before(weight_);
  saved.before(total_weight_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), NllLossBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto target = target_.unpack();
  auto weight = weight_.unpack();
  auto total_weight = total_weight_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(ignore_index);
  packed_args.pack(reduction);
  packed_args.pack(self);
  packed_args.pack(target);
  packed_args.pack(weight);
  packed_args.pack(total_weight);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(ignore_index);
  saved.after(reduction);
  saved.after(self_);
  saved.after(target_);
  saved.after(weight_);
  saved.after(total_weight_);
  return output_result;
#endif
}

static variable_list NllLoss2DBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, c10::SymInt& ignore_index, int64_t& reduction, Tensor& self, Tensor& target, Tensor& weight, Tensor& total_weight)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (nll_loss2d_backward_symint(grad, self, target, weight, reduction, ignore_index, total_weight)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list NllLoss2DBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto ignore_index = packed_args.unpack<c10::SymInt>();
  auto reduction = packed_args.unpack<int64_t>();
  auto self = packed_args.unpack<Tensor>();
  auto target = packed_args.unpack<Tensor>();
  auto weight = packed_args.unpack<Tensor>();
  auto total_weight = packed_args.unpack<Tensor>();
  return NllLoss2DBackward0_apply_functional(variable_list(grads), needs_input_grad, ignore_index, reduction, self, target, weight, total_weight);
#endif
}

variable_list NllLoss2DBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto target = target_.unpack();
  auto weight = weight_.unpack();
  auto total_weight = total_weight_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return NllLoss2DBackward0_apply_functional(std::move(grads), needs_input_grad, ignore_index, reduction, self, target, weight, total_weight);
}

void NllLoss2DBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(ignore_index);
    args.collect(reduction);
    args.collect(self_, false);
    args.collect(target_, false);
    args.collect(weight_, false);
    args.collect(total_weight_, true);
}
variable_list NllLoss2DBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(ignore_index);
  saved.before(reduction);
  saved.before(self_);
  saved.before(target_);
  saved.before(weight_);
  saved.before(total_weight_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), NllLoss2DBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto target = target_.unpack();
  auto weight = weight_.unpack();
  auto total_weight = total_weight_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(ignore_index);
  packed_args.pack(reduction);
  packed_args.pack(self);
  packed_args.pack(target);
  packed_args.pack(weight);
  packed_args.pack(total_weight);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(ignore_index);
  saved.after(reduction);
  saved.after(self_);
  saved.after(target_);
  saved.after(weight_);
  saved.after(total_weight_);
  return output_result;
#endif
}

static variable_list SmoothL1LossBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, double& beta, int64_t& reduction, Tensor& self, Tensor& target)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto target_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (smooth_l1_loss_backward(grad, self, target, reduction, beta)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  if (needs_input_grad[/*target*/1]) {
    auto grad_result = any_grad_defined ? (smooth_l1_loss_backward(grad, target, self, reduction, beta)) : Tensor();
    copy_range(grad_inputs, target_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SmoothL1LossBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto beta = packed_args.unpack<double>();
  auto reduction = packed_args.unpack<int64_t>();
  auto self = packed_args.unpack<Tensor>();
  auto target = packed_args.unpack<Tensor>();
  return SmoothL1LossBackward0_apply_functional(variable_list(grads), needs_input_grad, beta, reduction, self, target);
#endif
}

variable_list SmoothL1LossBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto target = target_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto target_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ target_ix }),
  };
  return SmoothL1LossBackward0_apply_functional(std::move(grads), needs_input_grad, beta, reduction, self, target);
}

void SmoothL1LossBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(beta);
    args.collect(reduction);
    args.collect(self_, false);
    args.collect(target_, false);
}
variable_list SmoothL1LossBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(beta);
  saved.before(reduction);
  saved.before(self_);
  saved.before(target_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<double>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SmoothL1LossBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto target = target_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto target_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ target_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(beta);
  packed_args.pack(reduction);
  packed_args.pack(self);
  packed_args.pack(target);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(beta);
  saved.after(reduction);
  saved.after(self_);
  saved.after(target_);
  return output_result;
#endif
}

static variable_list HuberLossBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, double& delta, int64_t& reduction, Tensor& self, Tensor& target)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto target_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (huber_loss_backward(grad, self, target, reduction, delta)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  if (needs_input_grad[/*target*/1]) {
    auto grad_result = any_grad_defined ? (huber_loss_backward(grad, target, self, reduction, delta)) : Tensor();
    copy_range(grad_inputs, target_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list HuberLossBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto delta = packed_args.unpack<double>();
  auto reduction = packed_args.unpack<int64_t>();
  auto self = packed_args.unpack<Tensor>();
  auto target = packed_args.unpack<Tensor>();
  return HuberLossBackward0_apply_functional(variable_list(grads), needs_input_grad, delta, reduction, self, target);
#endif
}

variable_list HuberLossBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto target = target_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto target_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ target_ix }),
  };
  return HuberLossBackward0_apply_functional(std::move(grads), needs_input_grad, delta, reduction, self, target);
}

void HuberLossBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(delta);
    args.collect(reduction);
    args.collect(self_, false);
    args.collect(target_, false);
}
variable_list HuberLossBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(delta);
  saved.before(reduction);
  saved.before(self_);
  saved.before(target_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<double>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), HuberLossBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto target = target_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto target_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ target_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(delta);
  packed_args.pack(reduction);
  packed_args.pack(self);
  packed_args.pack(target);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(delta);
  saved.after(reduction);
  saved.after(self_);
  saved.after(target_);
  return output_result;
#endif
}

static variable_list SoftMarginLossBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& reduction, Tensor& self, Tensor& target)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (soft_margin_loss_backward(grad, self, target, reduction)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SoftMarginLossBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto reduction = packed_args.unpack<int64_t>();
  auto self = packed_args.unpack<Tensor>();
  auto target = packed_args.unpack<Tensor>();
  return SoftMarginLossBackward0_apply_functional(variable_list(grads), needs_input_grad, reduction, self, target);
#endif
}

variable_list SoftMarginLossBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto target = target_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SoftMarginLossBackward0_apply_functional(std::move(grads), needs_input_grad, reduction, self, target);
}

void SoftMarginLossBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(reduction);
    args.collect(self_, false);
    args.collect(target_, false);
}
variable_list SoftMarginLossBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(reduction);
  saved.before(self_);
  saved.before(target_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SoftMarginLossBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto target = target_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(reduction);
  packed_args.pack(self);
  packed_args.pack(target);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(reduction);
  saved.after(self_);
  saved.after(target_);
  return output_result;
#endif
}

static variable_list ReluBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (threshold_backward(grad, result, 0)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ReluBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto result = packed_args.unpack<Tensor>();
  return ReluBackward0_apply_functional(variable_list(grads), needs_input_grad, result);
#endif
}

variable_list ReluBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ReluBackward0_apply_functional(std::move(grads), needs_input_grad, result);
}

void ReluBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(result_, true);
}
variable_list ReluBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ReluBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(result_);
  return output_result;
#endif
}

static variable_list SiluBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (GradMode::is_enabled() ? infinitely_differentiable_silu_backward(grad, self) : silu_backward(grad, self)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SiluBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  return SiluBackward0_apply_functional(variable_list(grads), needs_input_grad, self);
#endif
}

variable_list SiluBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SiluBackward0_apply_functional(std::move(grads), needs_input_grad, self);
}

void SiluBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list SiluBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SiluBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list MishBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (GradMode::is_enabled() ? infinitely_differentiable_mish_backward(grad, self) : mish_backward(grad, self)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list MishBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  return MishBackward0_apply_functional(variable_list(grads), needs_input_grad, self);
#endif
}

variable_list MishBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return MishBackward0_apply_functional(std::move(grads), needs_input_grad, self);
}

void MishBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list MishBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MishBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list EluBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, at::Scalar& alpha, at::Scalar& input_scale, at::Scalar& scale, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (elu_backward(grad, alpha, scale, input_scale, /* is_result */ false, self)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list EluBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto alpha = packed_args.unpack<at::Scalar>();
  auto input_scale = packed_args.unpack<at::Scalar>();
  auto scale = packed_args.unpack<at::Scalar>();
  auto self = packed_args.unpack<Tensor>();
  return EluBackward0_apply_functional(variable_list(grads), needs_input_grad, alpha, input_scale, scale, self);
#endif
}

variable_list EluBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return EluBackward0_apply_functional(std::move(grads), needs_input_grad, alpha, input_scale, scale, self);
}

void EluBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(alpha);
    args.collect(input_scale);
    args.collect(scale);
    args.collect(self_, false);
}
variable_list EluBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(alpha);
  saved.before(input_scale);
  saved.before(scale);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), EluBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(alpha);
  packed_args.pack(input_scale);
  packed_args.pack(scale);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(alpha);
  saved.after(input_scale);
  saved.after(scale);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list EluBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, at::Scalar& alpha, at::Scalar& input_scale, at::Scalar& scale, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (elu_backward(grad, alpha, scale, input_scale, /* is_result */ true, result)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list EluBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto alpha = packed_args.unpack<at::Scalar>();
  auto input_scale = packed_args.unpack<at::Scalar>();
  auto scale = packed_args.unpack<at::Scalar>();
  auto result = packed_args.unpack<Tensor>();
  return EluBackward1_apply_functional(variable_list(grads), needs_input_grad, alpha, input_scale, scale, result);
#endif
}

variable_list EluBackward1::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return EluBackward1_apply_functional(std::move(grads), needs_input_grad, alpha, input_scale, scale, result);
}

void EluBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(alpha);
    args.collect(input_scale);
    args.collect(scale);
    args.collect(result_, true);
}
variable_list EluBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(alpha);
  saved.before(input_scale);
  saved.before(scale);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), EluBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(alpha);
  packed_args.pack(input_scale);
  packed_args.pack(scale);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(alpha);
  saved.after(input_scale);
  saved.after(scale);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list CeluBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, at::Scalar& alpha, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (elu_backward(grad, alpha, 1, 1.0/alpha.toFloat(), /* is_result */ false, self)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list CeluBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto alpha = packed_args.unpack<at::Scalar>();
  auto self = packed_args.unpack<Tensor>();
  return CeluBackward0_apply_functional(variable_list(grads), needs_input_grad, alpha, self);
#endif
}

variable_list CeluBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return CeluBackward0_apply_functional(std::move(grads), needs_input_grad, alpha, self);
}

void CeluBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(alpha);
    args.collect(self_, false);
}
variable_list CeluBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(alpha);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), CeluBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(alpha);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(alpha);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list CeluBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, at::Scalar& alpha, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (elu_backward(grad, alpha, 1, 1.0/alpha.toFloat(), /* is_result */ true, result)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list CeluBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto alpha = packed_args.unpack<at::Scalar>();
  auto result = packed_args.unpack<Tensor>();
  return CeluBackward1_apply_functional(variable_list(grads), needs_input_grad, alpha, result);
#endif
}

variable_list CeluBackward1::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return CeluBackward1_apply_functional(std::move(grads), needs_input_grad, alpha, result);
}

void CeluBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(alpha);
    args.collect(result_, true);
}
variable_list CeluBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(alpha);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), CeluBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(alpha);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(alpha);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list GeluBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::string& approximate, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (gelu_backward(grad, self, approximate)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list GeluBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto approximate = packed_args.unpack<std::string>();
  auto self = packed_args.unpack<Tensor>();
  return GeluBackward0_apply_functional(variable_list(grads), needs_input_grad, approximate, self);
#endif
}

variable_list GeluBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return GeluBackward0_apply_functional(std::move(grads), needs_input_grad, approximate, self);
}

void GeluBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(approximate);
    args.collect(self_, false);
}
variable_list GeluBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(approximate);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::string>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), GeluBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(approximate);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(approximate);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list GeluBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, std::string& approximate, Tensor& grad_output, Tensor& self)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (gelu_backward(grad, self, approximate)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  if (needs_input_grad[/*self*/1]) {
    auto grad_result = any_grad_defined ? (gelu_double_backward(grad, grad_output, self, approximate)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list GeluBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto approximate = packed_args.unpack<std::string>();
  auto grad_output = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<Tensor>();
  return GeluBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, approximate, grad_output, self);
#endif
}

variable_list GeluBackwardBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto grad_output = grad_output_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  return GeluBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, approximate, grad_output, self);
}

void GeluBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(approximate);
    args.collect(grad_output_, false);
    args.collect(self_, false);
}
variable_list GeluBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(approximate);
  saved.before(grad_output_);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::string>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), GeluBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto grad_output = grad_output_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(approximate);
  packed_args.pack(grad_output);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(approximate);
  saved.after(grad_output_);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list GluBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (glu_backward(grad, self, dim)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list GluBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  auto self = packed_args.unpack<Tensor>();
  return GluBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, self);
#endif
}

variable_list GluBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return GluBackward0_apply_functional(std::move(grads), needs_input_grad, dim, self);
}

void GluBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(self_, false);
}
variable_list GluBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), GluBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list HardshrinkBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, at::Scalar& lambd, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (hardshrink_backward(grad, self, lambd)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list HardshrinkBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto lambd = packed_args.unpack<at::Scalar>();
  auto self = packed_args.unpack<Tensor>();
  return HardshrinkBackward0_apply_functional(variable_list(grads), needs_input_grad, lambd, self);
#endif
}

variable_list HardshrinkBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return HardshrinkBackward0_apply_functional(std::move(grads), needs_input_grad, lambd, self);
}

void HardshrinkBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(lambd);
    args.collect(self_, false);
}
variable_list HardshrinkBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(lambd);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), HardshrinkBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(lambd);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(lambd);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list HardshrinkBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, at::Scalar& lambd, Tensor& self)
{
  IndexRangeGenerator gen;
  auto grad_out_ix = gen.range(1);
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_out*/0]) {
    auto grad_result = any_grad_defined ? (hardshrink_backward(grad, self, lambd)) : Tensor();
    copy_range(grad_inputs, grad_out_ix, grad_result);
  }
  if (needs_input_grad[/*self*/1]) {
    auto grad_result = any_grad_defined ? (zeros_like(grad)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list HardshrinkBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto lambd = packed_args.unpack<at::Scalar>();
  auto self = packed_args.unpack<Tensor>();
  return HardshrinkBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, lambd, self);
#endif
}

variable_list HardshrinkBackwardBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto grad_out_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_out_ix }),
    task_should_compute_output({ self_ix }),
  };
  return HardshrinkBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, lambd, self);
}

void HardshrinkBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(lambd);
    args.collect(self_, false);
}
variable_list HardshrinkBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(lambd);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), HardshrinkBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto grad_out_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_out_ix }),
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(lambd);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(lambd);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list HardtanhBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, at::Scalar& max_val, at::Scalar& min_val, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (hardtanh_backward(grad, self, min_val, max_val)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list HardtanhBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto max_val = packed_args.unpack<at::Scalar>();
  auto min_val = packed_args.unpack<at::Scalar>();
  auto self = packed_args.unpack<Tensor>();
  return HardtanhBackward0_apply_functional(variable_list(grads), needs_input_grad, max_val, min_val, self);
#endif
}

variable_list HardtanhBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return HardtanhBackward0_apply_functional(std::move(grads), needs_input_grad, max_val, min_val, self);
}

void HardtanhBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(max_val);
    args.collect(min_val);
    args.collect(self_, false);
}
variable_list HardtanhBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(max_val);
  saved.before(min_val);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), HardtanhBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(max_val);
  packed_args.pack(min_val);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(max_val);
  saved.after(min_val);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list LeakyReluBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, at::Scalar& negative_slope, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (leaky_relu_backward(grad, self, negative_slope, false)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list LeakyReluBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto negative_slope = packed_args.unpack<at::Scalar>();
  auto self = packed_args.unpack<Tensor>();
  return LeakyReluBackward0_apply_functional(variable_list(grads), needs_input_grad, negative_slope, self);
#endif
}

variable_list LeakyReluBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return LeakyReluBackward0_apply_functional(std::move(grads), needs_input_grad, negative_slope, self);
}

void LeakyReluBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(negative_slope);
    args.collect(self_, false);
}
variable_list LeakyReluBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(negative_slope);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), LeakyReluBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(negative_slope);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(negative_slope);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list LeakyReluBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, at::Scalar& negative_slope, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (leaky_relu_backward(grad, result, negative_slope, true)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list LeakyReluBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto negative_slope = packed_args.unpack<at::Scalar>();
  auto result = packed_args.unpack<Tensor>();
  return LeakyReluBackward1_apply_functional(variable_list(grads), needs_input_grad, negative_slope, result);
#endif
}

variable_list LeakyReluBackward1::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return LeakyReluBackward1_apply_functional(std::move(grads), needs_input_grad, negative_slope, result);
}

void LeakyReluBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(negative_slope);
    args.collect(result_, true);
}
variable_list LeakyReluBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(negative_slope);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), LeakyReluBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(negative_slope);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(negative_slope);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list LogSigmoidBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self, Tensor& buffer)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (log_sigmoid_backward(grad, self, buffer)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list LogSigmoidBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  auto buffer = packed_args.unpack<Tensor>();
  return LogSigmoidBackward0_apply_functional(variable_list(grads), needs_input_grad, self, buffer);
#endif
}

variable_list LogSigmoidBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto buffer = buffer_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return LogSigmoidBackward0_apply_functional(std::move(grads), needs_input_grad, self, buffer);
}

void LogSigmoidBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
    args.collect(buffer_, true);
}
variable_list LogSigmoidBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);
  saved.before(buffer_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), LogSigmoidBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto buffer = buffer_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);
  packed_args.pack(buffer);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  saved.after(buffer_);
  return output_result;
#endif
}

static variable_list LogSoftmaxBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim, at::ScalarType& self_scalar_type, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (_log_softmax_backward_data(grad, result, dim, self_scalar_type)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list LogSoftmaxBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  auto self_scalar_type = packed_args.unpack<at::ScalarType>();
  auto result = packed_args.unpack<Tensor>();
  return LogSoftmaxBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, self_scalar_type, result);
#endif
}

variable_list LogSoftmaxBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return LogSoftmaxBackward0_apply_functional(std::move(grads), needs_input_grad, dim, self_scalar_type, result);
}

void LogSoftmaxBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(self_scalar_type);
    args.collect(result_, true);
}
variable_list LogSoftmaxBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(self_scalar_type);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::ScalarType>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), LogSoftmaxBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(self_scalar_type);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(self_scalar_type);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list SparseLogSoftmaxBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim, Tensor& self, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (_sparse_log_softmax_backward_data(grad, result, dim, self)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SparseLogSoftmaxBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  auto self = packed_args.unpack<Tensor>();
  auto result = packed_args.unpack<Tensor>();
  return SparseLogSoftmaxBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, self, result);
#endif
}

variable_list SparseLogSoftmaxBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SparseLogSoftmaxBackward0_apply_functional(std::move(grads), needs_input_grad, dim, self, result);
}

void SparseLogSoftmaxBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(self_, false);
    args.collect(result_, true);
}
variable_list SparseLogSoftmaxBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(self_);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SparseLogSoftmaxBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(self);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(self_);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list MaskedSoftmaxBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, ::std::optional<int64_t>& dim, Tensor& mask, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (_masked_softmax_backward(grad, result, mask, dim)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list MaskedSoftmaxBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<::std::optional<int64_t>>();
  auto mask = packed_args.unpack<Tensor>();
  auto result = packed_args.unpack<Tensor>();
  return MaskedSoftmaxBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, mask, result);
#endif
}

variable_list MaskedSoftmaxBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto mask = mask_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return MaskedSoftmaxBackward0_apply_functional(std::move(grads), needs_input_grad, dim, mask, result);
}

void MaskedSoftmaxBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(mask_, false);
    args.collect(result_, true);
}
variable_list MaskedSoftmaxBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(mask_);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MaskedSoftmaxBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto mask = mask_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(mask);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(mask_);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list PreluKernelBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& self, Tensor& weight)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1]) {
  
    auto grad_result = grad.defined() ? _prelu_kernel_backward(grad, self, weight) : std::tuple<Tensor, Tensor>();
      if (needs_input_grad[/*self*/0]) {
        copy_range(grad_inputs, self_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*weight*/1]) {
        copy_range(grad_inputs, weight_ix, std::get<1>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list PreluKernelBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto self = packed_args.unpack<Tensor>();
  auto weight = packed_args.unpack<Tensor>();
  return PreluKernelBackward0_apply_functional(variable_list(grads), needs_input_grad, self, weight);
#endif
}

variable_list PreluKernelBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ weight_ix }),
  };
  return PreluKernelBackward0_apply_functional(std::move(grads), needs_input_grad, self, weight);
}

void PreluKernelBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
    args.collect(weight_, false);
}
variable_list PreluKernelBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);
  saved.before(weight_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), PreluKernelBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ weight_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);
  packed_args.pack(weight);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  saved.after(weight_);
  return output_result;
#endif
}

static variable_list PreluKernelBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, Tensor& grad_output, at::TensorOptions& grad_output_options, Tensor& self, torch::autograd::generated::TypeAndSize& self_info, at::TensorOptions& self_options, Tensor& weight, at::TensorOptions& weight_options)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (grads[0].defined() ? (grads[1].defined() ? at::where(self >= 0, grads[0], grads[0] * weight + grads[1] * self) : at::where(self >= 0, grads[0], grads[0] * weight)) : at::where(self >= 0, at::zeros({}, grad_output_options), grads[1] * self)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  if (needs_input_grad[/*self*/1]) {
    auto grad_result = any_grad_defined ? (grads[1].defined() ? at::where(self >= 0, at::zeros({}, self_options), grad_output * grads[1]) : self_info.zeros()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  if (needs_input_grad[/*weight*/2]) {
    auto grad_result = any_grad_defined ? (grads[0].defined() ? at::where(self >= 0, at::zeros({}, weight_options), grad_output * grads[0]) : self_info.zeros()) : Tensor();
    copy_range(grad_inputs, weight_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list PreluKernelBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto grad_output = packed_args.unpack<Tensor>();
  auto grad_output_options = packed_args.unpack<at::TensorOptions>();
  auto self = packed_args.unpack<Tensor>();
  auto self_info = packed_args.unpack<torch::autograd::generated::TypeAndSize>();
  auto self_options = packed_args.unpack<at::TensorOptions>();
  auto weight = packed_args.unpack<Tensor>();
  auto weight_options = packed_args.unpack<at::TensorOptions>();
  return PreluKernelBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, grad_output, grad_output_options, self, self_info, self_options, weight, weight_options);
#endif
}

variable_list PreluKernelBackwardBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto grad_output = grad_output_.unpack();
  auto self = self_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ weight_ix }),
  };
  return PreluKernelBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, grad_output, grad_output_options, self, self_info, self_options, weight, weight_options);
}

void PreluKernelBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(grad_output_, false);
    args.collect(grad_output_options);
    args.collect(self_, false);
    args.collect(self_info);
    args.collect(self_options);
    args.collect(weight_, false);
    args.collect(weight_options);
}
variable_list PreluKernelBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(grad_output_);
  saved.before(grad_output_options);
  saved.before(self_);
  saved.before(self_info);
  saved.before(self_options);
  saved.before(weight_);
  saved.before(weight_options);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::TensorOptions>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::autograd::generated::TypeAndSize>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::TensorOptions>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::TensorOptions>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), PreluKernelBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto grad_output = grad_output_.unpack();
  auto self = self_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ weight_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(grad_output);
  packed_args.pack(grad_output_options);
  packed_args.pack(self);
  packed_args.pack(self_info);
  packed_args.pack(self_options);
  packed_args.pack(weight);
  packed_args.pack(weight_options);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(grad_output_);
  saved.after(grad_output_options);
  saved.after(self_);
  saved.after(self_info);
  saved.after(self_options);
  saved.after(weight_);
  saved.after(weight_options);
  return output_result;
#endif
}

static variable_list RreluWithNoiseBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, at::Scalar& lower, Tensor& noise, Tensor& self, bool& training, at::Scalar& upper)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (rrelu_with_noise_backward(grad, self, noise, lower, upper, training, false)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list RreluWithNoiseBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto lower = packed_args.unpack<at::Scalar>();
  auto noise = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<Tensor>();
  auto training = packed_args.unpack<bool>();
  auto upper = packed_args.unpack<at::Scalar>();
  return RreluWithNoiseBackward0_apply_functional(variable_list(grads), needs_input_grad, lower, noise, self, training, upper);
#endif
}

variable_list RreluWithNoiseBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto noise = noise_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return RreluWithNoiseBackward0_apply_functional(std::move(grads), needs_input_grad, lower, noise, self, training, upper);
}

void RreluWithNoiseBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(lower);
    args.collect(noise_, false);
    args.collect(self_, false);
    args.collect(training);
    args.collect(upper);
}
variable_list RreluWithNoiseBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(lower);
  saved.before(noise_);
  saved.before(self_);
  saved.before(training);
  saved.before(upper);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), RreluWithNoiseBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto noise = noise_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(lower);
  packed_args.pack(noise);
  packed_args.pack(self);
  packed_args.pack(training);
  packed_args.pack(upper);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(lower);
  saved.after(noise_);
  saved.after(self_);
  saved.after(training);
  saved.after(upper);
  return output_result;
#endif
}

static variable_list RreluWithNoiseBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, at::Scalar& lower, Tensor& noise, bool& training, at::Scalar& upper, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (rrelu_with_noise_backward(grad, result, noise, lower, upper, training, true)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list RreluWithNoiseBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto lower = packed_args.unpack<at::Scalar>();
  auto noise = packed_args.unpack<Tensor>();
  auto training = packed_args.unpack<bool>();
  auto upper = packed_args.unpack<at::Scalar>();
  auto result = packed_args.unpack<Tensor>();
  return RreluWithNoiseBackward1_apply_functional(variable_list(grads), needs_input_grad, lower, noise, training, upper, result);
#endif
}

variable_list RreluWithNoiseBackward1::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto noise = noise_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return RreluWithNoiseBackward1_apply_functional(std::move(grads), needs_input_grad, lower, noise, training, upper, result);
}

void RreluWithNoiseBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(lower);
    args.collect(noise_, false);
    args.collect(training);
    args.collect(upper);
    args.collect(result_, true);
}
variable_list RreluWithNoiseBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(lower);
  saved.before(noise_);
  saved.before(training);
  saved.before(upper);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), RreluWithNoiseBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto noise = noise_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(lower);
  packed_args.pack(noise);
  packed_args.pack(training);
  packed_args.pack(upper);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(lower);
  saved.after(noise_);
  saved.after(training);
  saved.after(upper);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list RreluWithNoiseFunctionalBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, at::Scalar& lower, Tensor& noise, Tensor& self, bool& training, at::Scalar& upper)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (rrelu_with_noise_backward(grad, self, noise, lower, upper, training, false)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list RreluWithNoiseFunctionalBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto lower = packed_args.unpack<at::Scalar>();
  auto noise = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<Tensor>();
  auto training = packed_args.unpack<bool>();
  auto upper = packed_args.unpack<at::Scalar>();
  return RreluWithNoiseFunctionalBackward0_apply_functional(variable_list(grads), needs_input_grad, lower, noise, self, training, upper);
#endif
}

variable_list RreluWithNoiseFunctionalBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto noise = noise_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return RreluWithNoiseFunctionalBackward0_apply_functional(std::move(grads), needs_input_grad, lower, noise, self, training, upper);
}

void RreluWithNoiseFunctionalBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(lower);
    args.collect(noise_, false);
    args.collect(self_, false);
    args.collect(training);
    args.collect(upper);
}
variable_list RreluWithNoiseFunctionalBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(lower);
  saved.before(noise_);
  saved.before(self_);
  saved.before(training);
  saved.before(upper);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), RreluWithNoiseFunctionalBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto noise = noise_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(lower);
  packed_args.pack(noise);
  packed_args.pack(self);
  packed_args.pack(training);
  packed_args.pack(upper);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(lower);
  saved.after(noise_);
  saved.after(self_);
  saved.after(training);
  saved.after(upper);
  return output_result;
#endif
}

static variable_list SoftmaxBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim, at::ScalarType& self_scalar_type, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (_softmax_backward_data(grad, result, dim, self_scalar_type)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SoftmaxBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  auto self_scalar_type = packed_args.unpack<at::ScalarType>();
  auto result = packed_args.unpack<Tensor>();
  return SoftmaxBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, self_scalar_type, result);
#endif
}

variable_list SoftmaxBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SoftmaxBackward0_apply_functional(std::move(grads), needs_input_grad, dim, self_scalar_type, result);
}

void SoftmaxBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(self_scalar_type);
    args.collect(result_, true);
}
variable_list SoftmaxBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(self_scalar_type);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::ScalarType>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SoftmaxBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(self_scalar_type);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(self_scalar_type);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list SparseSoftmaxBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim, Tensor& self, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (_sparse_softmax_backward_data(grad, result, dim, self)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SparseSoftmaxBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  auto self = packed_args.unpack<Tensor>();
  auto result = packed_args.unpack<Tensor>();
  return SparseSoftmaxBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, self, result);
#endif
}

variable_list SparseSoftmaxBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SparseSoftmaxBackward0_apply_functional(std::move(grads), needs_input_grad, dim, self, result);
}

void SparseSoftmaxBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(self_, false);
    args.collect(result_, true);
}
variable_list SparseSoftmaxBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(self_);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SparseSoftmaxBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(self);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(self_);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list SparseSparseMatmulBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& other, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*other*/1]) {
    auto grad_result = any_grad_defined ? (sparse_sparse_matmul_backward(grad, self, other, 1)) : Tensor();
    copy_range(grad_inputs, other_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (sparse_sparse_matmul_backward(grad, self, other, 0)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SparseSparseMatmulBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto other = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<Tensor>();
  return SparseSparseMatmulBackward0_apply_functional(variable_list(grads), needs_input_grad, other, self);
#endif
}

variable_list SparseSparseMatmulBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto other = other_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  return SparseSparseMatmulBackward0_apply_functional(std::move(grads), needs_input_grad, other, self);
}

void SparseSparseMatmulBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(other_, false);
    args.collect(self_, false);
}
variable_list SparseSparseMatmulBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(other_);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SparseSparseMatmulBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto other = other_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(other);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(other_);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list SoftplusBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, at::Scalar& beta, Tensor& self, at::Scalar& threshold)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (softplus_backward(grad, self, beta, threshold)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SoftplusBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto beta = packed_args.unpack<at::Scalar>();
  auto self = packed_args.unpack<Tensor>();
  auto threshold = packed_args.unpack<at::Scalar>();
  return SoftplusBackward0_apply_functional(variable_list(grads), needs_input_grad, beta, self, threshold);
#endif
}

variable_list SoftplusBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SoftplusBackward0_apply_functional(std::move(grads), needs_input_grad, beta, self, threshold);
}

void SoftplusBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(beta);
    args.collect(self_, false);
    args.collect(threshold);
}
variable_list SoftplusBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(beta);
  saved.before(self_);
  saved.before(threshold);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SoftplusBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(beta);
  packed_args.pack(self);
  packed_args.pack(threshold);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(beta);
  saved.after(self_);
  saved.after(threshold);
  return output_result;
#endif
}

static variable_list SoftshrinkBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, at::Scalar& lambd, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (softshrink_backward(grad, self, lambd)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SoftshrinkBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto lambd = packed_args.unpack<at::Scalar>();
  auto self = packed_args.unpack<Tensor>();
  return SoftshrinkBackward0_apply_functional(variable_list(grads), needs_input_grad, lambd, self);
#endif
}

variable_list SoftshrinkBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SoftshrinkBackward0_apply_functional(std::move(grads), needs_input_grad, lambd, self);
}

void SoftshrinkBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(lambd);
    args.collect(self_, false);
}
variable_list SoftshrinkBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(lambd);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SoftshrinkBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(lambd);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(lambd);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list ThresholdBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self, at::Scalar& threshold)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (threshold_backward(grad, self, threshold)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ThresholdBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  auto threshold = packed_args.unpack<at::Scalar>();
  return ThresholdBackward0_apply_functional(variable_list(grads), needs_input_grad, self, threshold);
#endif
}

variable_list ThresholdBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ThresholdBackward0_apply_functional(std::move(grads), needs_input_grad, self, threshold);
}

void ThresholdBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
    args.collect(threshold);
}
variable_list ThresholdBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);
  saved.before(threshold);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ThresholdBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);
  packed_args.pack(threshold);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  saved.after(threshold);
  return output_result;
#endif
}

static variable_list ThresholdBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self, at::Scalar& threshold)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (threshold_backward(grad, self, threshold)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ThresholdBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  auto threshold = packed_args.unpack<at::Scalar>();
  return ThresholdBackward1_apply_functional(variable_list(grads), needs_input_grad, self, threshold);
#endif
}

variable_list ThresholdBackward1::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ThresholdBackward1_apply_functional(std::move(grads), needs_input_grad, self, threshold);
}

void ThresholdBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
    args.collect(threshold);
}
variable_list ThresholdBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);
  saved.before(threshold);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ThresholdBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);
  packed_args.pack(threshold);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  saved.after(threshold);
  return output_result;
#endif
}

static variable_list ReflectionPad1DBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<c10::SymInt>& padding, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (reflection_pad1d_backward_symint(grad, self, padding)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ReflectionPad1DBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto padding = packed_args.unpack<std::vector<c10::SymInt>>();
  auto self = packed_args.unpack<Tensor>();
  return ReflectionPad1DBackward0_apply_functional(variable_list(grads), needs_input_grad, padding, self);
#endif
}

variable_list ReflectionPad1DBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ReflectionPad1DBackward0_apply_functional(std::move(grads), needs_input_grad, padding, self);
}

void ReflectionPad1DBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(padding);
    args.collect(self_, false);
}
variable_list ReflectionPad1DBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(padding);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ReflectionPad1DBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(padding);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(padding);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list ReflectionPad2DBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<c10::SymInt>& padding, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (reflection_pad2d_backward_symint(grad, self, padding)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ReflectionPad2DBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto padding = packed_args.unpack<std::vector<c10::SymInt>>();
  auto self = packed_args.unpack<Tensor>();
  return ReflectionPad2DBackward0_apply_functional(variable_list(grads), needs_input_grad, padding, self);
#endif
}

variable_list ReflectionPad2DBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ReflectionPad2DBackward0_apply_functional(std::move(grads), needs_input_grad, padding, self);
}

void ReflectionPad2DBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(padding);
    args.collect(self_, false);
}
variable_list ReflectionPad2DBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(padding);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ReflectionPad2DBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(padding);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(padding);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list ReflectionPad3DBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<c10::SymInt>& padding, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (reflection_pad3d_backward_symint(grad, self, padding)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ReflectionPad3DBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto padding = packed_args.unpack<std::vector<c10::SymInt>>();
  auto self = packed_args.unpack<Tensor>();
  return ReflectionPad3DBackward0_apply_functional(variable_list(grads), needs_input_grad, padding, self);
#endif
}

variable_list ReflectionPad3DBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ReflectionPad3DBackward0_apply_functional(std::move(grads), needs_input_grad, padding, self);
}

void ReflectionPad3DBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(padding);
    args.collect(self_, false);
}
variable_list ReflectionPad3DBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(padding);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ReflectionPad3DBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(padding);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(padding);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list ReplicationPad1DBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<c10::SymInt>& padding, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (replication_pad1d_backward_symint(grad, self, padding)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ReplicationPad1DBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto padding = packed_args.unpack<std::vector<c10::SymInt>>();
  auto self = packed_args.unpack<Tensor>();
  return ReplicationPad1DBackward0_apply_functional(variable_list(grads), needs_input_grad, padding, self);
#endif
}

variable_list ReplicationPad1DBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ReplicationPad1DBackward0_apply_functional(std::move(grads), needs_input_grad, padding, self);
}

void ReplicationPad1DBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(padding);
    args.collect(self_, false);
}
variable_list ReplicationPad1DBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(padding);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ReplicationPad1DBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(padding);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(padding);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list ReplicationPad2DBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<c10::SymInt>& padding, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (replication_pad2d_backward_symint(grad, self, padding)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ReplicationPad2DBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto padding = packed_args.unpack<std::vector<c10::SymInt>>();
  auto self = packed_args.unpack<Tensor>();
  return ReplicationPad2DBackward0_apply_functional(variable_list(grads), needs_input_grad, padding, self);
#endif
}

variable_list ReplicationPad2DBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ReplicationPad2DBackward0_apply_functional(std::move(grads), needs_input_grad, padding, self);
}

void ReplicationPad2DBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(padding);
    args.collect(self_, false);
}
variable_list ReplicationPad2DBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(padding);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ReplicationPad2DBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(padding);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(padding);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list ReplicationPad3DBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<c10::SymInt>& padding, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (replication_pad3d_backward_symint(grad, self, padding)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ReplicationPad3DBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto padding = packed_args.unpack<std::vector<c10::SymInt>>();
  auto self = packed_args.unpack<Tensor>();
  return ReplicationPad3DBackward0_apply_functional(variable_list(grads), needs_input_grad, padding, self);
#endif
}

variable_list ReplicationPad3DBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ReplicationPad3DBackward0_apply_functional(std::move(grads), needs_input_grad, padding, self);
}

void ReplicationPad3DBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(padding);
    args.collect(self_, false);
}
variable_list ReplicationPad3DBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(padding);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ReplicationPad3DBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(padding);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(padding);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list UpsampleLinear1DBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, bool& align_corners, std::vector<c10::SymInt>& output_size, ::std::optional<double>& scales, std::vector<c10::SymInt>& self_sym_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (upsample_linear1d_backward_symint(grad, output_size, self_sym_sizes, align_corners, scales)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list UpsampleLinear1DBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto align_corners = packed_args.unpack<bool>();
  auto output_size = packed_args.unpack<std::vector<c10::SymInt>>();
  auto scales = packed_args.unpack<::std::optional<double>>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return UpsampleLinear1DBackward0_apply_functional(variable_list(grads), needs_input_grad, align_corners, output_size, scales, self_sym_sizes);
#endif
}

variable_list UpsampleLinear1DBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return UpsampleLinear1DBackward0_apply_functional(std::move(grads), needs_input_grad, align_corners, output_size, scales, self_sym_sizes);
}

void UpsampleLinear1DBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(align_corners);
    args.collect(output_size);
    args.collect(scales);
    args.collect(self_sym_sizes);
}
variable_list UpsampleLinear1DBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(align_corners);
  saved.before(output_size);
  saved.before(scales);
  saved.before(self_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), UpsampleLinear1DBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(align_corners);
  packed_args.pack(output_size);
  packed_args.pack(scales);
  packed_args.pack(self_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(align_corners);
  saved.after(output_size);
  saved.after(scales);
  saved.after(self_sym_sizes);
  return output_result;
#endif
}

static variable_list UpsampleBilinear2DBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, bool& align_corners, std::vector<c10::SymInt>& output_size, ::std::optional<double>& scales_h, ::std::optional<double>& scales_w, std::vector<c10::SymInt>& self_sym_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (upsample_bilinear2d_backward_symint(grad, output_size, self_sym_sizes, align_corners, scales_h, scales_w)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list UpsampleBilinear2DBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto align_corners = packed_args.unpack<bool>();
  auto output_size = packed_args.unpack<std::vector<c10::SymInt>>();
  auto scales_h = packed_args.unpack<::std::optional<double>>();
  auto scales_w = packed_args.unpack<::std::optional<double>>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return UpsampleBilinear2DBackward0_apply_functional(variable_list(grads), needs_input_grad, align_corners, output_size, scales_h, scales_w, self_sym_sizes);
#endif
}

variable_list UpsampleBilinear2DBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return UpsampleBilinear2DBackward0_apply_functional(std::move(grads), needs_input_grad, align_corners, output_size, scales_h, scales_w, self_sym_sizes);
}

void UpsampleBilinear2DBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(align_corners);
    args.collect(output_size);
    args.collect(scales_h);
    args.collect(scales_w);
    args.collect(self_sym_sizes);
}
variable_list UpsampleBilinear2DBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(align_corners);
  saved.before(output_size);
  saved.before(scales_h);
  saved.before(scales_w);
  saved.before(self_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), UpsampleBilinear2DBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(align_corners);
  packed_args.pack(output_size);
  packed_args.pack(scales_h);
  packed_args.pack(scales_w);
  packed_args.pack(self_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(align_corners);
  saved.after(output_size);
  saved.after(scales_h);
  saved.after(scales_w);
  saved.after(self_sym_sizes);
  return output_result;
#endif
}

static variable_list UpsampleBilinear2DAaBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, bool& align_corners, std::vector<c10::SymInt>& output_size, ::std::optional<double>& scales_h, ::std::optional<double>& scales_w, std::vector<c10::SymInt>& self_sym_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (_upsample_bilinear2d_aa_backward_symint(grad, output_size, self_sym_sizes, align_corners, scales_h, scales_w)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list UpsampleBilinear2DAaBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto align_corners = packed_args.unpack<bool>();
  auto output_size = packed_args.unpack<std::vector<c10::SymInt>>();
  auto scales_h = packed_args.unpack<::std::optional<double>>();
  auto scales_w = packed_args.unpack<::std::optional<double>>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return UpsampleBilinear2DAaBackward0_apply_functional(variable_list(grads), needs_input_grad, align_corners, output_size, scales_h, scales_w, self_sym_sizes);
#endif
}

variable_list UpsampleBilinear2DAaBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return UpsampleBilinear2DAaBackward0_apply_functional(std::move(grads), needs_input_grad, align_corners, output_size, scales_h, scales_w, self_sym_sizes);
}

void UpsampleBilinear2DAaBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(align_corners);
    args.collect(output_size);
    args.collect(scales_h);
    args.collect(scales_w);
    args.collect(self_sym_sizes);
}
variable_list UpsampleBilinear2DAaBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(align_corners);
  saved.before(output_size);
  saved.before(scales_h);
  saved.before(scales_w);
  saved.before(self_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), UpsampleBilinear2DAaBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(align_corners);
  packed_args.pack(output_size);
  packed_args.pack(scales_h);
  packed_args.pack(scales_w);
  packed_args.pack(self_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(align_corners);
  saved.after(output_size);
  saved.after(scales_h);
  saved.after(scales_w);
  saved.after(self_sym_sizes);
  return output_result;
#endif
}

static variable_list UpsampleBicubic2DBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, bool& align_corners, std::vector<c10::SymInt>& output_size, ::std::optional<double>& scales_h, ::std::optional<double>& scales_w, std::vector<c10::SymInt>& self_sym_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (upsample_bicubic2d_backward_symint(grad, output_size, self_sym_sizes, align_corners, scales_h, scales_w)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list UpsampleBicubic2DBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto align_corners = packed_args.unpack<bool>();
  auto output_size = packed_args.unpack<std::vector<c10::SymInt>>();
  auto scales_h = packed_args.unpack<::std::optional<double>>();
  auto scales_w = packed_args.unpack<::std::optional<double>>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return UpsampleBicubic2DBackward0_apply_functional(variable_list(grads), needs_input_grad, align_corners, output_size, scales_h, scales_w, self_sym_sizes);
#endif
}

variable_list UpsampleBicubic2DBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return UpsampleBicubic2DBackward0_apply_functional(std::move(grads), needs_input_grad, align_corners, output_size, scales_h, scales_w, self_sym_sizes);
}

void UpsampleBicubic2DBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(align_corners);
    args.collect(output_size);
    args.collect(scales_h);
    args.collect(scales_w);
    args.collect(self_sym_sizes);
}
variable_list UpsampleBicubic2DBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(align_corners);
  saved.before(output_size);
  saved.before(scales_h);
  saved.before(scales_w);
  saved.before(self_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), UpsampleBicubic2DBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(align_corners);
  packed_args.pack(output_size);
  packed_args.pack(scales_h);
  packed_args.pack(scales_w);
  packed_args.pack(self_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(align_corners);
  saved.after(output_size);
  saved.after(scales_h);
  saved.after(scales_w);
  saved.after(self_sym_sizes);
  return output_result;
#endif
}

static variable_list UpsampleBicubic2DAaBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, bool& align_corners, std::vector<c10::SymInt>& output_size, ::std::optional<double>& scales_h, ::std::optional<double>& scales_w, std::vector<c10::SymInt>& self_sym_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (_upsample_bicubic2d_aa_backward_symint(grad, output_size, self_sym_sizes, align_corners, scales_h, scales_w)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list UpsampleBicubic2DAaBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto align_corners = packed_args.unpack<bool>();
  auto output_size = packed_args.unpack<std::vector<c10::SymInt>>();
  auto scales_h = packed_args.unpack<::std::optional<double>>();
  auto scales_w = packed_args.unpack<::std::optional<double>>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return UpsampleBicubic2DAaBackward0_apply_functional(variable_list(grads), needs_input_grad, align_corners, output_size, scales_h, scales_w, self_sym_sizes);
#endif
}

variable_list UpsampleBicubic2DAaBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return UpsampleBicubic2DAaBackward0_apply_functional(std::move(grads), needs_input_grad, align_corners, output_size, scales_h, scales_w, self_sym_sizes);
}

void UpsampleBicubic2DAaBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(align_corners);
    args.collect(output_size);
    args.collect(scales_h);
    args.collect(scales_w);
    args.collect(self_sym_sizes);
}
variable_list UpsampleBicubic2DAaBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(align_corners);
  saved.before(output_size);
  saved.before(scales_h);
  saved.before(scales_w);
  saved.before(self_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), UpsampleBicubic2DAaBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(align_corners);
  packed_args.pack(output_size);
  packed_args.pack(scales_h);
  packed_args.pack(scales_w);
  packed_args.pack(self_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(align_corners);
  saved.after(output_size);
  saved.after(scales_h);
  saved.after(scales_w);
  saved.after(self_sym_sizes);
  return output_result;
#endif
}

static variable_list UpsampleTrilinear3DBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, bool& align_corners, std::vector<c10::SymInt>& output_size, ::std::optional<double>& scales_d, ::std::optional<double>& scales_h, ::std::optional<double>& scales_w, std::vector<c10::SymInt>& self_sym_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (upsample_trilinear3d_backward_symint(grad, output_size, self_sym_sizes, align_corners, scales_d, scales_h, scales_w)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list UpsampleTrilinear3DBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto align_corners = packed_args.unpack<bool>();
  auto output_size = packed_args.unpack<std::vector<c10::SymInt>>();
  auto scales_d = packed_args.unpack<::std::optional<double>>();
  auto scales_h = packed_args.unpack<::std::optional<double>>();
  auto scales_w = packed_args.unpack<::std::optional<double>>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return UpsampleTrilinear3DBackward0_apply_functional(variable_list(grads), needs_input_grad, align_corners, output_size, scales_d, scales_h, scales_w, self_sym_sizes);
#endif
}

variable_list UpsampleTrilinear3DBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return UpsampleTrilinear3DBackward0_apply_functional(std::move(grads), needs_input_grad, align_corners, output_size, scales_d, scales_h, scales_w, self_sym_sizes);
}

void UpsampleTrilinear3DBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(align_corners);
    args.collect(output_size);
    args.collect(scales_d);
    args.collect(scales_h);
    args.collect(scales_w);
    args.collect(self_sym_sizes);
}
variable_list UpsampleTrilinear3DBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(align_corners);
  saved.before(output_size);
  saved.before(scales_d);
  saved.before(scales_h);
  saved.before(scales_w);
  saved.before(self_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), UpsampleTrilinear3DBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(align_corners);
  packed_args.pack(output_size);
  packed_args.pack(scales_d);
  packed_args.pack(scales_h);
  packed_args.pack(scales_w);
  packed_args.pack(self_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(align_corners);
  saved.after(output_size);
  saved.after(scales_d);
  saved.after(scales_h);
  saved.after(scales_w);
  saved.after(self_sym_sizes);
  return output_result;
#endif
}

static variable_list UpsampleNearest1DBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<c10::SymInt>& output_size, ::std::optional<double>& scales, std::vector<c10::SymInt>& self_sym_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (upsample_nearest1d_backward_symint(grad, output_size, self_sym_sizes, scales)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list UpsampleNearest1DBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto output_size = packed_args.unpack<std::vector<c10::SymInt>>();
  auto scales = packed_args.unpack<::std::optional<double>>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return UpsampleNearest1DBackward0_apply_functional(variable_list(grads), needs_input_grad, output_size, scales, self_sym_sizes);
#endif
}

variable_list UpsampleNearest1DBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return UpsampleNearest1DBackward0_apply_functional(std::move(grads), needs_input_grad, output_size, scales, self_sym_sizes);
}

void UpsampleNearest1DBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(output_size);
    args.collect(scales);
    args.collect(self_sym_sizes);
}
variable_list UpsampleNearest1DBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(output_size);
  saved.before(scales);
  saved.before(self_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), UpsampleNearest1DBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(output_size);
  packed_args.pack(scales);
  packed_args.pack(self_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(output_size);
  saved.after(scales);
  saved.after(self_sym_sizes);
  return output_result;
#endif
}

static variable_list UpsampleNearestExact1DBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<c10::SymInt>& output_size, ::std::optional<double>& scales, std::vector<c10::SymInt>& self_sym_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (_upsample_nearest_exact1d_backward_symint(grad, output_size, self_sym_sizes, scales)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list UpsampleNearestExact1DBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto output_size = packed_args.unpack<std::vector<c10::SymInt>>();
  auto scales = packed_args.unpack<::std::optional<double>>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return UpsampleNearestExact1DBackward0_apply_functional(variable_list(grads), needs_input_grad, output_size, scales, self_sym_sizes);
#endif
}

variable_list UpsampleNearestExact1DBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return UpsampleNearestExact1DBackward0_apply_functional(std::move(grads), needs_input_grad, output_size, scales, self_sym_sizes);
}

void UpsampleNearestExact1DBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(output_size);
    args.collect(scales);
    args.collect(self_sym_sizes);
}
variable_list UpsampleNearestExact1DBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(output_size);
  saved.before(scales);
  saved.before(self_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), UpsampleNearestExact1DBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(output_size);
  packed_args.pack(scales);
  packed_args.pack(self_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(output_size);
  saved.after(scales);
  saved.after(self_sym_sizes);
  return output_result;
#endif
}

static variable_list UpsampleNearest2DBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<c10::SymInt>& output_size, ::std::optional<double>& scales_h, ::std::optional<double>& scales_w, std::vector<c10::SymInt>& self_sym_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (upsample_nearest2d_backward_symint(grad, output_size, self_sym_sizes, scales_h, scales_w)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list UpsampleNearest2DBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto output_size = packed_args.unpack<std::vector<c10::SymInt>>();
  auto scales_h = packed_args.unpack<::std::optional<double>>();
  auto scales_w = packed_args.unpack<::std::optional<double>>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return UpsampleNearest2DBackward0_apply_functional(variable_list(grads), needs_input_grad, output_size, scales_h, scales_w, self_sym_sizes);
#endif
}

variable_list UpsampleNearest2DBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return UpsampleNearest2DBackward0_apply_functional(std::move(grads), needs_input_grad, output_size, scales_h, scales_w, self_sym_sizes);
}

void UpsampleNearest2DBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(output_size);
    args.collect(scales_h);
    args.collect(scales_w);
    args.collect(self_sym_sizes);
}
variable_list UpsampleNearest2DBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(output_size);
  saved.before(scales_h);
  saved.before(scales_w);
  saved.before(self_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), UpsampleNearest2DBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(output_size);
  packed_args.pack(scales_h);
  packed_args.pack(scales_w);
  packed_args.pack(self_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(output_size);
  saved.after(scales_h);
  saved.after(scales_w);
  saved.after(self_sym_sizes);
  return output_result;
#endif
}

static variable_list UpsampleNearestExact2DBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<c10::SymInt>& output_size, ::std::optional<double>& scales_h, ::std::optional<double>& scales_w, std::vector<c10::SymInt>& self_sym_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (_upsample_nearest_exact2d_backward_symint(grad, output_size, self_sym_sizes, scales_h, scales_w)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list UpsampleNearestExact2DBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto output_size = packed_args.unpack<std::vector<c10::SymInt>>();
  auto scales_h = packed_args.unpack<::std::optional<double>>();
  auto scales_w = packed_args.unpack<::std::optional<double>>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return UpsampleNearestExact2DBackward0_apply_functional(variable_list(grads), needs_input_grad, output_size, scales_h, scales_w, self_sym_sizes);
#endif
}

variable_list UpsampleNearestExact2DBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return UpsampleNearestExact2DBackward0_apply_functional(std::move(grads), needs_input_grad, output_size, scales_h, scales_w, self_sym_sizes);
}

void UpsampleNearestExact2DBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(output_size);
    args.collect(scales_h);
    args.collect(scales_w);
    args.collect(self_sym_sizes);
}
variable_list UpsampleNearestExact2DBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(output_size);
  saved.before(scales_h);
  saved.before(scales_w);
  saved.before(self_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), UpsampleNearestExact2DBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(output_size);
  packed_args.pack(scales_h);
  packed_args.pack(scales_w);
  packed_args.pack(self_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(output_size);
  saved.after(scales_h);
  saved.after(scales_w);
  saved.after(self_sym_sizes);
  return output_result;
#endif
}

static variable_list UpsampleNearest3DBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<c10::SymInt>& output_size, ::std::optional<double>& scales_d, ::std::optional<double>& scales_h, ::std::optional<double>& scales_w, std::vector<c10::SymInt>& self_sym_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (upsample_nearest3d_backward_symint(grad, output_size, self_sym_sizes, scales_d, scales_h, scales_w)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list UpsampleNearest3DBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto output_size = packed_args.unpack<std::vector<c10::SymInt>>();
  auto scales_d = packed_args.unpack<::std::optional<double>>();
  auto scales_h = packed_args.unpack<::std::optional<double>>();
  auto scales_w = packed_args.unpack<::std::optional<double>>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return UpsampleNearest3DBackward0_apply_functional(variable_list(grads), needs_input_grad, output_size, scales_d, scales_h, scales_w, self_sym_sizes);
#endif
}

variable_list UpsampleNearest3DBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return UpsampleNearest3DBackward0_apply_functional(std::move(grads), needs_input_grad, output_size, scales_d, scales_h, scales_w, self_sym_sizes);
}

void UpsampleNearest3DBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(output_size);
    args.collect(scales_d);
    args.collect(scales_h);
    args.collect(scales_w);
    args.collect(self_sym_sizes);
}
variable_list UpsampleNearest3DBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(output_size);
  saved.before(scales_d);
  saved.before(scales_h);
  saved.before(scales_w);
  saved.before(self_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), UpsampleNearest3DBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(output_size);
  packed_args.pack(scales_d);
  packed_args.pack(scales_h);
  packed_args.pack(scales_w);
  packed_args.pack(self_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(output_size);
  saved.after(scales_d);
  saved.after(scales_h);
  saved.after(scales_w);
  saved.after(self_sym_sizes);
  return output_result;
#endif
}

static variable_list UpsampleNearestExact3DBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<c10::SymInt>& output_size, ::std::optional<double>& scales_d, ::std::optional<double>& scales_h, ::std::optional<double>& scales_w, std::vector<c10::SymInt>& self_sym_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (_upsample_nearest_exact3d_backward_symint(grad, output_size, self_sym_sizes, scales_d, scales_h, scales_w)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list UpsampleNearestExact3DBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto output_size = packed_args.unpack<std::vector<c10::SymInt>>();
  auto scales_d = packed_args.unpack<::std::optional<double>>();
  auto scales_h = packed_args.unpack<::std::optional<double>>();
  auto scales_w = packed_args.unpack<::std::optional<double>>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return UpsampleNearestExact3DBackward0_apply_functional(variable_list(grads), needs_input_grad, output_size, scales_d, scales_h, scales_w, self_sym_sizes);
#endif
}

variable_list UpsampleNearestExact3DBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return UpsampleNearestExact3DBackward0_apply_functional(std::move(grads), needs_input_grad, output_size, scales_d, scales_h, scales_w, self_sym_sizes);
}

void UpsampleNearestExact3DBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(output_size);
    args.collect(scales_d);
    args.collect(scales_h);
    args.collect(scales_w);
    args.collect(self_sym_sizes);
}
variable_list UpsampleNearestExact3DBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(output_size);
  saved.before(scales_d);
  saved.before(scales_h);
  saved.before(scales_w);
  saved.before(self_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), UpsampleNearestExact3DBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(output_size);
  packed_args.pack(scales_d);
  packed_args.pack(scales_h);
  packed_args.pack(scales_w);
  packed_args.pack(self_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(output_size);
  saved.after(scales_d);
  saved.after(scales_h);
  saved.after(scales_w);
  saved.after(self_sym_sizes);
  return output_result;
#endif
}

static variable_list PixelShuffleBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& upscale_factor)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (pixel_unshuffle(grad, upscale_factor)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list PixelShuffleBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto upscale_factor = packed_args.unpack<int64_t>();
  return PixelShuffleBackward0_apply_functional(variable_list(grads), needs_input_grad, upscale_factor);
#endif
}

variable_list PixelShuffleBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return PixelShuffleBackward0_apply_functional(std::move(grads), needs_input_grad, upscale_factor);
}

void PixelShuffleBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(upscale_factor);
}
variable_list PixelShuffleBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(upscale_factor);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), PixelShuffleBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(upscale_factor);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(upscale_factor);
  return output_result;
#endif
}

static variable_list PixelUnshuffleBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& downscale_factor)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (pixel_shuffle(grad, downscale_factor)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list PixelUnshuffleBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto downscale_factor = packed_args.unpack<int64_t>();
  return PixelUnshuffleBackward0_apply_functional(variable_list(grads), needs_input_grad, downscale_factor);
#endif
}

variable_list PixelUnshuffleBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return PixelUnshuffleBackward0_apply_functional(std::move(grads), needs_input_grad, downscale_factor);
}

void PixelUnshuffleBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(downscale_factor);
}
variable_list PixelUnshuffleBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(downscale_factor);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), PixelUnshuffleBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(downscale_factor);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(downscale_factor);
  return output_result;
#endif
}

static variable_list ChannelShuffleBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, c10::SymInt& groups)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (channel_shuffle_symint(grad, grad.sym_size(1) / groups)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ChannelShuffleBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto groups = packed_args.unpack<c10::SymInt>();
  return ChannelShuffleBackward0_apply_functional(variable_list(grads), needs_input_grad, groups);
#endif
}

variable_list ChannelShuffleBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ChannelShuffleBackward0_apply_functional(std::move(grads), needs_input_grad, groups);
}

void ChannelShuffleBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(groups);
}
variable_list ChannelShuffleBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(groups);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ChannelShuffleBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(groups);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(groups);
  return output_result;
#endif
}

static variable_list AdaptiveAvgPool2DBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (_adaptive_avg_pool2d_backward(grad, self)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list AdaptiveAvgPool2DBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  return AdaptiveAvgPool2DBackward0_apply_functional(variable_list(grads), needs_input_grad, self);
#endif
}

variable_list AdaptiveAvgPool2DBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return AdaptiveAvgPool2DBackward0_apply_functional(std::move(grads), needs_input_grad, self);
}

void AdaptiveAvgPool2DBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list AdaptiveAvgPool2DBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), AdaptiveAvgPool2DBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list AdaptiveAvgPool3DBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (_adaptive_avg_pool3d_backward(grad, self)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list AdaptiveAvgPool3DBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  return AdaptiveAvgPool3DBackward0_apply_functional(variable_list(grads), needs_input_grad, self);
#endif
}

variable_list AdaptiveAvgPool3DBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return AdaptiveAvgPool3DBackward0_apply_functional(std::move(grads), needs_input_grad, self);
}

void AdaptiveAvgPool3DBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list AdaptiveAvgPool3DBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), AdaptiveAvgPool3DBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list AdaptiveMaxPool2DBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self, Tensor& result1)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (adaptive_max_pool2d_backward(grad, self, result1)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list AdaptiveMaxPool2DBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  auto result1 = packed_args.unpack<Tensor>();
  return AdaptiveMaxPool2DBackward0_apply_functional(variable_list(grads), needs_input_grad, self, result1);
#endif
}

variable_list AdaptiveMaxPool2DBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto result1 = result1_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return AdaptiveMaxPool2DBackward0_apply_functional(std::move(grads), needs_input_grad, self, result1);
}

void AdaptiveMaxPool2DBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
    args.collect(result1_, true);
}
variable_list AdaptiveMaxPool2DBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);
  saved.before(result1_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), AdaptiveMaxPool2DBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto result1 = result1_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);
  packed_args.pack(result1);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  saved.after(result1_);
  return output_result;
#endif
}

static variable_list AdaptiveMaxPool3DBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self, Tensor& result1)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (adaptive_max_pool3d_backward(grad, self, result1)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list AdaptiveMaxPool3DBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  auto result1 = packed_args.unpack<Tensor>();
  return AdaptiveMaxPool3DBackward0_apply_functional(variable_list(grads), needs_input_grad, self, result1);
#endif
}

variable_list AdaptiveMaxPool3DBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto result1 = result1_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return AdaptiveMaxPool3DBackward0_apply_functional(std::move(grads), needs_input_grad, self, result1);
}

void AdaptiveMaxPool3DBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
    args.collect(result1_, true);
}
variable_list AdaptiveMaxPool3DBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);
  saved.before(result1_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), AdaptiveMaxPool3DBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto result1 = result1_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);
  packed_args.pack(result1);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  saved.after(result1_);
  return output_result;
#endif
}

static variable_list AvgPool2DBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, bool& ceil_mode, bool& count_include_pad, ::std::optional<int64_t>& divisor_override, std::vector<int64_t>& kernel_size, std::vector<int64_t>& padding, Tensor& self, std::vector<int64_t>& stride)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (avg_pool2d_backward(grad, self, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list AvgPool2DBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto ceil_mode = packed_args.unpack<bool>();
  auto count_include_pad = packed_args.unpack<bool>();
  auto divisor_override = packed_args.unpack<::std::optional<int64_t>>();
  auto kernel_size = packed_args.unpack<std::vector<int64_t>>();
  auto padding = packed_args.unpack<std::vector<int64_t>>();
  auto self = packed_args.unpack<Tensor>();
  auto stride = packed_args.unpack<std::vector<int64_t>>();
  return AvgPool2DBackward0_apply_functional(variable_list(grads), needs_input_grad, ceil_mode, count_include_pad, divisor_override, kernel_size, padding, self, stride);
#endif
}

variable_list AvgPool2DBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return AvgPool2DBackward0_apply_functional(std::move(grads), needs_input_grad, ceil_mode, count_include_pad, divisor_override, kernel_size, padding, self, stride);
}

void AvgPool2DBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(ceil_mode);
    args.collect(count_include_pad);
    args.collect(divisor_override);
    args.collect(kernel_size);
    args.collect(padding);
    args.collect(self_, false);
    args.collect(stride);
}
variable_list AvgPool2DBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(ceil_mode);
  saved.before(count_include_pad);
  saved.before(divisor_override);
  saved.before(kernel_size);
  saved.before(padding);
  saved.before(self_);
  saved.before(stride);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), AvgPool2DBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(ceil_mode);
  packed_args.pack(count_include_pad);
  packed_args.pack(divisor_override);
  packed_args.pack(kernel_size);
  packed_args.pack(padding);
  packed_args.pack(self);
  packed_args.pack(stride);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(ceil_mode);
  saved.after(count_include_pad);
  saved.after(divisor_override);
  saved.after(kernel_size);
  saved.after(padding);
  saved.after(self_);
  saved.after(stride);
  return output_result;
#endif
}

static variable_list AvgPool3DBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, bool& ceil_mode, bool& count_include_pad, ::std::optional<int64_t>& divisor_override, std::vector<int64_t>& kernel_size, std::vector<int64_t>& padding, Tensor& self, std::vector<int64_t>& stride)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (avg_pool3d_backward(grad, self, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list AvgPool3DBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto ceil_mode = packed_args.unpack<bool>();
  auto count_include_pad = packed_args.unpack<bool>();
  auto divisor_override = packed_args.unpack<::std::optional<int64_t>>();
  auto kernel_size = packed_args.unpack<std::vector<int64_t>>();
  auto padding = packed_args.unpack<std::vector<int64_t>>();
  auto self = packed_args.unpack<Tensor>();
  auto stride = packed_args.unpack<std::vector<int64_t>>();
  return AvgPool3DBackward0_apply_functional(variable_list(grads), needs_input_grad, ceil_mode, count_include_pad, divisor_override, kernel_size, padding, self, stride);
#endif
}

variable_list AvgPool3DBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return AvgPool3DBackward0_apply_functional(std::move(grads), needs_input_grad, ceil_mode, count_include_pad, divisor_override, kernel_size, padding, self, stride);
}

void AvgPool3DBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(ceil_mode);
    args.collect(count_include_pad);
    args.collect(divisor_override);
    args.collect(kernel_size);
    args.collect(padding);
    args.collect(self_, false);
    args.collect(stride);
}
variable_list AvgPool3DBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(ceil_mode);
  saved.before(count_include_pad);
  saved.before(divisor_override);
  saved.before(kernel_size);
  saved.before(padding);
  saved.before(self_);
  saved.before(stride);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), AvgPool3DBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(ceil_mode);
  packed_args.pack(count_include_pad);
  packed_args.pack(divisor_override);
  packed_args.pack(kernel_size);
  packed_args.pack(padding);
  packed_args.pack(self);
  packed_args.pack(stride);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(ceil_mode);
  saved.after(count_include_pad);
  saved.after(divisor_override);
  saved.after(kernel_size);
  saved.after(padding);
  saved.after(self_);
  saved.after(stride);
  return output_result;
#endif
}

static variable_list FractionalMaxPool2DBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<int64_t>& kernel_size, std::vector<int64_t>& output_size, Tensor& self, Tensor& result1)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (fractional_max_pool2d_backward(grad, self, kernel_size, output_size, result1)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list FractionalMaxPool2DBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto kernel_size = packed_args.unpack<std::vector<int64_t>>();
  auto output_size = packed_args.unpack<std::vector<int64_t>>();
  auto self = packed_args.unpack<Tensor>();
  auto result1 = packed_args.unpack<Tensor>();
  return FractionalMaxPool2DBackward0_apply_functional(variable_list(grads), needs_input_grad, kernel_size, output_size, self, result1);
#endif
}

variable_list FractionalMaxPool2DBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto result1 = result1_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return FractionalMaxPool2DBackward0_apply_functional(std::move(grads), needs_input_grad, kernel_size, output_size, self, result1);
}

void FractionalMaxPool2DBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(kernel_size);
    args.collect(output_size);
    args.collect(self_, false);
    args.collect(result1_, true);
}
variable_list FractionalMaxPool2DBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(kernel_size);
  saved.before(output_size);
  saved.before(self_);
  saved.before(result1_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), FractionalMaxPool2DBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto result1 = result1_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(kernel_size);
  packed_args.pack(output_size);
  packed_args.pack(self);
  packed_args.pack(result1);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(kernel_size);
  saved.after(output_size);
  saved.after(self_);
  saved.after(result1_);
  return output_result;
#endif
}

static variable_list FractionalMaxPool3DBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<int64_t>& kernel_size, std::vector<int64_t>& output_size, Tensor& self, Tensor& result1)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (fractional_max_pool3d_backward(grad, self, kernel_size, output_size, result1)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list FractionalMaxPool3DBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto kernel_size = packed_args.unpack<std::vector<int64_t>>();
  auto output_size = packed_args.unpack<std::vector<int64_t>>();
  auto self = packed_args.unpack<Tensor>();
  auto result1 = packed_args.unpack<Tensor>();
  return FractionalMaxPool3DBackward0_apply_functional(variable_list(grads), needs_input_grad, kernel_size, output_size, self, result1);
#endif
}

variable_list FractionalMaxPool3DBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto result1 = result1_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return FractionalMaxPool3DBackward0_apply_functional(std::move(grads), needs_input_grad, kernel_size, output_size, self, result1);
}

void FractionalMaxPool3DBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(kernel_size);
    args.collect(output_size);
    args.collect(self_, false);
    args.collect(result1_, true);
}
variable_list FractionalMaxPool3DBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(kernel_size);
  saved.before(output_size);
  saved.before(self_);
  saved.before(result1_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), FractionalMaxPool3DBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto result1 = result1_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(kernel_size);
  packed_args.pack(output_size);
  packed_args.pack(self);
  packed_args.pack(result1);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(kernel_size);
  saved.after(output_size);
  saved.after(self_);
  saved.after(result1_);
  return output_result;
#endif
}

static variable_list LinearBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, Tensor& input, Tensor& weight)
{
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1] || needs_input_grad[2]) {
      auto grad_input_mask = std::array<bool, 3>{
        needs_input_grad[0],
        needs_input_grad[1],
        needs_input_grad[2],
      };
    auto grad_result = grad.defined() ? linear_backward(input, grad, weight, grad_input_mask) : std::tuple<Tensor, Tensor, Tensor>();
      if (needs_input_grad[/*input*/0]) {
        copy_range(grad_inputs, input_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*weight*/1]) {
        copy_range(grad_inputs, weight_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*bias*/2]) {
        copy_range(grad_inputs, bias_ix, std::get<2>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list LinearBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto input = packed_args.unpack<Tensor>();
  auto weight = packed_args.unpack<Tensor>();
  return LinearBackward0_apply_functional(variable_list(grads), needs_input_grad, input, weight);
#endif
}

variable_list LinearBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto input = input_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  return LinearBackward0_apply_functional(std::move(grads), needs_input_grad, input, weight);
}

void LinearBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(input_, false);
    args.collect(weight_, false);
}
variable_list LinearBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(input_);
  saved.before(weight_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), LinearBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto input = input_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(input);
  packed_args.pack(weight);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(input_);
  saved.after(weight_);
  return output_result;
#endif
}

static variable_list LinearBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, Tensor& grad_output, Tensor& self, Tensor& weight)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto grad_output_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[0] || needs_input_grad[1] || needs_input_grad[2]) {
  
    auto grad_result = linear_double_backward(grads, self, grad_output, weight);
      if (needs_input_grad[/*self*/0]) {
        copy_range(grad_inputs, self_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*grad_output*/1]) {
        copy_range(grad_inputs, grad_output_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*weight*/2]) {
        copy_range(grad_inputs, weight_ix, std::get<2>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list LinearBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto grad_output = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<Tensor>();
  auto weight = packed_args.unpack<Tensor>();
  return LinearBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, grad_output, self, weight);
#endif
}

variable_list LinearBackwardBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto grad_output = grad_output_.unpack();
  auto self = self_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto grad_output_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ weight_ix }),
  };
  return LinearBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, grad_output, self, weight);
}

void LinearBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(grad_output_, false);
    args.collect(self_, false);
    args.collect(weight_, false);
}
variable_list LinearBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(grad_output_);
  saved.before(self_);
  saved.before(weight_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), LinearBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto grad_output = grad_output_.unpack();
  auto self = self_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto grad_output_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ weight_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(grad_output);
  packed_args.pack(self);
  packed_args.pack(weight);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(grad_output_);
  saved.after(self_);
  saved.after(weight_);
  return output_result;
#endif
}

static variable_list MaxPool2DBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, bool& ceil_mode, std::vector<int64_t>& dilation, std::vector<int64_t>& kernel_size, std::vector<int64_t>& padding, Tensor& self, std::vector<int64_t>& stride)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (max_pool2d_backward(grad, self, kernel_size, stride, padding, dilation, ceil_mode)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list MaxPool2DBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto ceil_mode = packed_args.unpack<bool>();
  auto dilation = packed_args.unpack<std::vector<int64_t>>();
  auto kernel_size = packed_args.unpack<std::vector<int64_t>>();
  auto padding = packed_args.unpack<std::vector<int64_t>>();
  auto self = packed_args.unpack<Tensor>();
  auto stride = packed_args.unpack<std::vector<int64_t>>();
  return MaxPool2DBackward0_apply_functional(variable_list(grads), needs_input_grad, ceil_mode, dilation, kernel_size, padding, self, stride);
#endif
}

variable_list MaxPool2DBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return MaxPool2DBackward0_apply_functional(std::move(grads), needs_input_grad, ceil_mode, dilation, kernel_size, padding, self, stride);
}

void MaxPool2DBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(ceil_mode);
    args.collect(dilation);
    args.collect(kernel_size);
    args.collect(padding);
    args.collect(self_, false);
    args.collect(stride);
}
variable_list MaxPool2DBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(ceil_mode);
  saved.before(dilation);
  saved.before(kernel_size);
  saved.before(padding);
  saved.before(self_);
  saved.before(stride);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MaxPool2DBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(ceil_mode);
  packed_args.pack(dilation);
  packed_args.pack(kernel_size);
  packed_args.pack(padding);
  packed_args.pack(self);
  packed_args.pack(stride);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(ceil_mode);
  saved.after(dilation);
  saved.after(kernel_size);
  saved.after(padding);
  saved.after(self_);
  saved.after(stride);
  return output_result;
#endif
}

static variable_list MpsConvolutionBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, std::vector<c10::SymInt>& dilation, c10::SymInt& groups, std::vector<c10::SymInt>& padding, Tensor& self, std::vector<c10::SymInt>& stride, Tensor& weight)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1] || needs_input_grad[2]) {
      auto grad_input_mask = std::array<bool, 3>{
        needs_input_grad[0],
        needs_input_grad[1],
        needs_input_grad[2],
      };
    auto grad_result = grad.defined() ? mps_convolution_backward_symint(self, grad, weight, padding, stride, dilation, groups, grad_input_mask) : std::tuple<Tensor, Tensor, Tensor>();
      if (needs_input_grad[/*self*/0]) {
        copy_range(grad_inputs, self_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*weight*/1]) {
        copy_range(grad_inputs, weight_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*bias*/2]) {
        copy_range(grad_inputs, bias_ix, std::get<2>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list MpsConvolutionBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto dilation = packed_args.unpack<std::vector<c10::SymInt>>();
  auto groups = packed_args.unpack<c10::SymInt>();
  auto padding = packed_args.unpack<std::vector<c10::SymInt>>();
  auto self = packed_args.unpack<Tensor>();
  auto stride = packed_args.unpack<std::vector<c10::SymInt>>();
  auto weight = packed_args.unpack<Tensor>();
  return MpsConvolutionBackward0_apply_functional(variable_list(grads), needs_input_grad, dilation, groups, padding, self, stride, weight);
#endif
}

variable_list MpsConvolutionBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  return MpsConvolutionBackward0_apply_functional(std::move(grads), needs_input_grad, dilation, groups, padding, self, stride, weight);
}

void MpsConvolutionBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dilation);
    args.collect(groups);
    args.collect(padding);
    args.collect(self_, false);
    args.collect(stride);
    args.collect(weight_, false);
}
variable_list MpsConvolutionBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dilation);
  saved.before(groups);
  saved.before(padding);
  saved.before(self_);
  saved.before(stride);
  saved.before(weight_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MpsConvolutionBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dilation);
  packed_args.pack(groups);
  packed_args.pack(padding);
  packed_args.pack(self);
  packed_args.pack(stride);
  packed_args.pack(weight);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dilation);
  saved.after(groups);
  saved.after(padding);
  saved.after(self_);
  saved.after(stride);
  saved.after(weight_);
  return output_result;
#endif
}

static variable_list MpsConvolutionBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, std::vector<c10::SymInt>& dilation, Tensor& grad_output, c10::SymInt& groups, std::vector<c10::SymInt>& padding, Tensor& self, std::vector<c10::SymInt>& stride, Tensor& weight)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto grad_output_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[1] || needs_input_grad[0] || needs_input_grad[2]) {
      auto grad_input_mask = std::array<bool, 3>{
        needs_input_grad[1],
        needs_input_grad[0],
        needs_input_grad[2],
      };
    auto grad_result = _convolution_double_backward_symint(grads[0], grads[1], grads[2], grad_output, weight, self, stride, padding, dilation, false, std::vector<c10::SymInt>(padding.size(), 0), groups, grad_input_mask);
      if (needs_input_grad[/*grad_output*/1]) {
        copy_range(grad_inputs, grad_output_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*self*/0]) {
        copy_range(grad_inputs, self_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*weight*/2]) {
        copy_range(grad_inputs, weight_ix, std::get<2>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list MpsConvolutionBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto dilation = packed_args.unpack<std::vector<c10::SymInt>>();
  auto grad_output = packed_args.unpack<Tensor>();
  auto groups = packed_args.unpack<c10::SymInt>();
  auto padding = packed_args.unpack<std::vector<c10::SymInt>>();
  auto self = packed_args.unpack<Tensor>();
  auto stride = packed_args.unpack<std::vector<c10::SymInt>>();
  auto weight = packed_args.unpack<Tensor>();
  return MpsConvolutionBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, dilation, grad_output, groups, padding, self, stride, weight);
#endif
}

variable_list MpsConvolutionBackwardBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto grad_output = grad_output_.unpack();
  auto self = self_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto grad_output_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ weight_ix }),
  };
  return MpsConvolutionBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, dilation, grad_output, groups, padding, self, stride, weight);
}

void MpsConvolutionBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dilation);
    args.collect(grad_output_, false);
    args.collect(groups);
    args.collect(padding);
    args.collect(self_, false);
    args.collect(stride);
    args.collect(weight_, false);
}
variable_list MpsConvolutionBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dilation);
  saved.before(grad_output_);
  saved.before(groups);
  saved.before(padding);
  saved.before(self_);
  saved.before(stride);
  saved.before(weight_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MpsConvolutionBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto grad_output = grad_output_.unpack();
  auto self = self_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto grad_output_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ weight_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dilation);
  packed_args.pack(grad_output);
  packed_args.pack(groups);
  packed_args.pack(padding);
  packed_args.pack(self);
  packed_args.pack(stride);
  packed_args.pack(weight);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dilation);
  saved.after(grad_output_);
  saved.after(groups);
  saved.after(padding);
  saved.after(self_);
  saved.after(stride);
  saved.after(weight_);
  return output_result;
#endif
}

static variable_list MaxPool2DWithIndicesBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, bool& ceil_mode, std::vector<int64_t>& dilation, std::vector<int64_t>& kernel_size, std::vector<int64_t>& padding, Tensor& self, std::vector<int64_t>& stride, Tensor& result1)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (max_pool2d_with_indices_backward(grad, self, kernel_size, stride, padding, dilation, ceil_mode, result1)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list MaxPool2DWithIndicesBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto ceil_mode = packed_args.unpack<bool>();
  auto dilation = packed_args.unpack<std::vector<int64_t>>();
  auto kernel_size = packed_args.unpack<std::vector<int64_t>>();
  auto padding = packed_args.unpack<std::vector<int64_t>>();
  auto self = packed_args.unpack<Tensor>();
  auto stride = packed_args.unpack<std::vector<int64_t>>();
  auto result1 = packed_args.unpack<Tensor>();
  return MaxPool2DWithIndicesBackward0_apply_functional(variable_list(grads), needs_input_grad, ceil_mode, dilation, kernel_size, padding, self, stride, result1);
#endif
}

variable_list MaxPool2DWithIndicesBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto result1 = result1_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return MaxPool2DWithIndicesBackward0_apply_functional(std::move(grads), needs_input_grad, ceil_mode, dilation, kernel_size, padding, self, stride, result1);
}

void MaxPool2DWithIndicesBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(ceil_mode);
    args.collect(dilation);
    args.collect(kernel_size);
    args.collect(padding);
    args.collect(self_, false);
    args.collect(stride);
    args.collect(result1_, true);
}
variable_list MaxPool2DWithIndicesBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(ceil_mode);
  saved.before(dilation);
  saved.before(kernel_size);
  saved.before(padding);
  saved.before(self_);
  saved.before(stride);
  saved.before(result1_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MaxPool2DWithIndicesBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto result1 = result1_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(ceil_mode);
  packed_args.pack(dilation);
  packed_args.pack(kernel_size);
  packed_args.pack(padding);
  packed_args.pack(self);
  packed_args.pack(stride);
  packed_args.pack(result1);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(ceil_mode);
  saved.after(dilation);
  saved.after(kernel_size);
  saved.after(padding);
  saved.after(self_);
  saved.after(stride);
  saved.after(result1_);
  return output_result;
#endif
}

static variable_list MaxPool3DWithIndicesBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, bool& ceil_mode, std::vector<int64_t>& dilation, std::vector<int64_t>& kernel_size, std::vector<int64_t>& padding, Tensor& self, std::vector<int64_t>& stride, Tensor& result1)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (max_pool3d_with_indices_backward(grad, self, kernel_size, stride, padding, dilation, ceil_mode, result1)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list MaxPool3DWithIndicesBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto ceil_mode = packed_args.unpack<bool>();
  auto dilation = packed_args.unpack<std::vector<int64_t>>();
  auto kernel_size = packed_args.unpack<std::vector<int64_t>>();
  auto padding = packed_args.unpack<std::vector<int64_t>>();
  auto self = packed_args.unpack<Tensor>();
  auto stride = packed_args.unpack<std::vector<int64_t>>();
  auto result1 = packed_args.unpack<Tensor>();
  return MaxPool3DWithIndicesBackward0_apply_functional(variable_list(grads), needs_input_grad, ceil_mode, dilation, kernel_size, padding, self, stride, result1);
#endif
}

variable_list MaxPool3DWithIndicesBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto result1 = result1_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return MaxPool3DWithIndicesBackward0_apply_functional(std::move(grads), needs_input_grad, ceil_mode, dilation, kernel_size, padding, self, stride, result1);
}

void MaxPool3DWithIndicesBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(ceil_mode);
    args.collect(dilation);
    args.collect(kernel_size);
    args.collect(padding);
    args.collect(self_, false);
    args.collect(stride);
    args.collect(result1_, true);
}
variable_list MaxPool3DWithIndicesBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(ceil_mode);
  saved.before(dilation);
  saved.before(kernel_size);
  saved.before(padding);
  saved.before(self_);
  saved.before(stride);
  saved.before(result1_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MaxPool3DWithIndicesBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto result1 = result1_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(ceil_mode);
  packed_args.pack(dilation);
  packed_args.pack(kernel_size);
  packed_args.pack(padding);
  packed_args.pack(self);
  packed_args.pack(stride);
  packed_args.pack(result1);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(ceil_mode);
  saved.after(dilation);
  saved.after(kernel_size);
  saved.after(padding);
  saved.after(self_);
  saved.after(stride);
  saved.after(result1_);
  return output_result;
#endif
}

static variable_list MaxUnpool2DBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& indices)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (max_pool_double_backward(grad, indices, 2)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list MaxUnpool2DBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto indices = packed_args.unpack<Tensor>();
  return MaxUnpool2DBackward0_apply_functional(variable_list(grads), needs_input_grad, indices);
#endif
}

variable_list MaxUnpool2DBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto indices = indices_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return MaxUnpool2DBackward0_apply_functional(std::move(grads), needs_input_grad, indices);
}

void MaxUnpool2DBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(indices_, false);
}
variable_list MaxUnpool2DBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(indices_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MaxUnpool2DBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto indices = indices_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(indices);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(indices_);
  return output_result;
#endif
}

static variable_list MaxUnpool3DBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& indices)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (max_pool_double_backward(grad, indices, 3)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list MaxUnpool3DBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto indices = packed_args.unpack<Tensor>();
  return MaxUnpool3DBackward0_apply_functional(variable_list(grads), needs_input_grad, indices);
#endif
}

variable_list MaxUnpool3DBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto indices = indices_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return MaxUnpool3DBackward0_apply_functional(std::move(grads), needs_input_grad, indices);
}

void MaxUnpool3DBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(indices_, false);
}
variable_list MaxUnpool3DBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(indices_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MaxUnpool3DBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto indices = indices_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(indices);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(indices_);
  return output_result;
#endif
}

static variable_list ConvolutionBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, c10::OptionalArray<c10::SymInt>& bias_sym_sizes_opt, std::vector<c10::SymInt>& dilation, c10::SymInt& groups, Tensor& input, std::vector<c10::SymInt>& output_padding, std::vector<c10::SymInt>& padding, std::vector<c10::SymInt>& stride, bool& transposed, Tensor& weight)
{
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1] || needs_input_grad[2]) {
      auto grad_input_mask = std::array<bool, 3>{
        needs_input_grad[0],
        needs_input_grad[1],
        needs_input_grad[2],
      };
    auto grad_result = grad.defined() ? convolution_backward_symint(grad, input, weight, bias_sym_sizes_opt, stride, padding, dilation, transposed, output_padding, groups, grad_input_mask) : std::tuple<Tensor, Tensor, Tensor>();
      if (needs_input_grad[/*input*/0]) {
        copy_range(grad_inputs, input_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*weight*/1]) {
        copy_range(grad_inputs, weight_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*bias*/2]) {
        copy_range(grad_inputs, bias_ix, std::get<2>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list ConvolutionBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto bias_sym_sizes_opt = packed_args.unpack<c10::OptionalArray<c10::SymInt>>();
  auto dilation = packed_args.unpack<std::vector<c10::SymInt>>();
  auto groups = packed_args.unpack<c10::SymInt>();
  auto input = packed_args.unpack<Tensor>();
  auto output_padding = packed_args.unpack<std::vector<c10::SymInt>>();
  auto padding = packed_args.unpack<std::vector<c10::SymInt>>();
  auto stride = packed_args.unpack<std::vector<c10::SymInt>>();
  auto transposed = packed_args.unpack<bool>();
  auto weight = packed_args.unpack<Tensor>();
  return ConvolutionBackward0_apply_functional(variable_list(grads), needs_input_grad, bias_sym_sizes_opt, dilation, groups, input, output_padding, padding, stride, transposed, weight);
#endif
}

variable_list ConvolutionBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto input = input_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  return ConvolutionBackward0_apply_functional(std::move(grads), needs_input_grad, bias_sym_sizes_opt, dilation, groups, input, output_padding, padding, stride, transposed, weight);
}

void ConvolutionBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(bias_sym_sizes_opt);
    args.collect(dilation);
    args.collect(groups);
    args.collect(input_, false);
    args.collect(output_padding);
    args.collect(padding);
    args.collect(stride);
    args.collect(transposed);
    args.collect(weight_, false);
}
variable_list ConvolutionBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(bias_sym_sizes_opt);
  saved.before(dilation);
  saved.before(groups);
  saved.before(input_);
  saved.before(output_padding);
  saved.before(padding);
  saved.before(stride);
  saved.before(transposed);
  saved.before(weight_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::OptionalArray<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ConvolutionBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto input = input_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(bias_sym_sizes_opt);
  packed_args.pack(dilation);
  packed_args.pack(groups);
  packed_args.pack(input);
  packed_args.pack(output_padding);
  packed_args.pack(padding);
  packed_args.pack(stride);
  packed_args.pack(transposed);
  packed_args.pack(weight);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(bias_sym_sizes_opt);
  saved.after(dilation);
  saved.after(groups);
  saved.after(input_);
  saved.after(output_padding);
  saved.after(padding);
  saved.after(stride);
  saved.after(transposed);
  saved.after(weight_);
  return output_result;
#endif
}

static variable_list ConvolutionBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, c10::OptionalArray<c10::SymInt>& bias_sym_sizes_opt, std::vector<c10::SymInt>& dilation, c10::SymInt& groups, Tensor& input, std::vector<c10::SymInt>& output_padding, std::vector<c10::SymInt>& padding, std::vector<c10::SymInt>& stride, bool& transposed, Tensor& weight)
{
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1] || needs_input_grad[2]) {
      auto grad_input_mask = std::array<bool, 3>{
        needs_input_grad[0],
        needs_input_grad[1],
        needs_input_grad[2],
      };
    auto grad_result = grad.defined() ? convolution_backward_symint(grad, input, weight, bias_sym_sizes_opt, stride, padding, dilation, transposed, output_padding, groups, grad_input_mask) : std::tuple<Tensor, Tensor, Tensor>();
      if (needs_input_grad[/*input*/0]) {
        copy_range(grad_inputs, input_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*weight*/1]) {
        copy_range(grad_inputs, weight_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*bias*/2]) {
        copy_range(grad_inputs, bias_ix, std::get<2>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list ConvolutionBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto bias_sym_sizes_opt = packed_args.unpack<c10::OptionalArray<c10::SymInt>>();
  auto dilation = packed_args.unpack<std::vector<c10::SymInt>>();
  auto groups = packed_args.unpack<c10::SymInt>();
  auto input = packed_args.unpack<Tensor>();
  auto output_padding = packed_args.unpack<std::vector<c10::SymInt>>();
  auto padding = packed_args.unpack<std::vector<c10::SymInt>>();
  auto stride = packed_args.unpack<std::vector<c10::SymInt>>();
  auto transposed = packed_args.unpack<bool>();
  auto weight = packed_args.unpack<Tensor>();
  return ConvolutionBackward1_apply_functional(variable_list(grads), needs_input_grad, bias_sym_sizes_opt, dilation, groups, input, output_padding, padding, stride, transposed, weight);
#endif
}

variable_list ConvolutionBackward1::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto input = input_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  return ConvolutionBackward1_apply_functional(std::move(grads), needs_input_grad, bias_sym_sizes_opt, dilation, groups, input, output_padding, padding, stride, transposed, weight);
}

void ConvolutionBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(bias_sym_sizes_opt);
    args.collect(dilation);
    args.collect(groups);
    args.collect(input_, false);
    args.collect(output_padding);
    args.collect(padding);
    args.collect(stride);
    args.collect(transposed);
    args.collect(weight_, false);
}
variable_list ConvolutionBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(bias_sym_sizes_opt);
  saved.before(dilation);
  saved.before(groups);
  saved.before(input_);
  saved.before(output_padding);
  saved.before(padding);
  saved.before(stride);
  saved.before(transposed);
  saved.before(weight_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::OptionalArray<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ConvolutionBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto input = input_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(bias_sym_sizes_opt);
  packed_args.pack(dilation);
  packed_args.pack(groups);
  packed_args.pack(input);
  packed_args.pack(output_padding);
  packed_args.pack(padding);
  packed_args.pack(stride);
  packed_args.pack(transposed);
  packed_args.pack(weight);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(bias_sym_sizes_opt);
  saved.after(dilation);
  saved.after(groups);
  saved.after(input_);
  saved.after(output_padding);
  saved.after(padding);
  saved.after(stride);
  saved.after(transposed);
  saved.after(weight_);
  return output_result;
#endif
}

static variable_list ConvolutionBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, std::vector<c10::SymInt>& dilation, Tensor& grad_output, c10::SymInt& groups, Tensor& input, std::vector<c10::SymInt>& output_padding, std::vector<c10::SymInt>& padding, std::vector<c10::SymInt>& stride, bool& transposed, Tensor& weight)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[0] || needs_input_grad[1] || needs_input_grad[2]) {
      auto grad_input_mask = std::array<bool, 3>{
        needs_input_grad[0],
        needs_input_grad[1],
        needs_input_grad[2],
      };
    auto grad_result = _convolution_double_backward_symint(grads[0], grads[1], grads[2], grad_output, weight, input, stride, padding, dilation, transposed, output_padding, groups, grad_input_mask);
      if (needs_input_grad[/*grad_output*/0]) {
        copy_range(grad_inputs, grad_output_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*input*/1]) {
        copy_range(grad_inputs, input_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*weight*/2]) {
        copy_range(grad_inputs, weight_ix, std::get<2>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list ConvolutionBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto dilation = packed_args.unpack<std::vector<c10::SymInt>>();
  auto grad_output = packed_args.unpack<Tensor>();
  auto groups = packed_args.unpack<c10::SymInt>();
  auto input = packed_args.unpack<Tensor>();
  auto output_padding = packed_args.unpack<std::vector<c10::SymInt>>();
  auto padding = packed_args.unpack<std::vector<c10::SymInt>>();
  auto stride = packed_args.unpack<std::vector<c10::SymInt>>();
  auto transposed = packed_args.unpack<bool>();
  auto weight = packed_args.unpack<Tensor>();
  return ConvolutionBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, dilation, grad_output, groups, input, output_padding, padding, stride, transposed, weight);
#endif
}

variable_list ConvolutionBackwardBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto grad_output = grad_output_.unpack();
  auto input = input_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ weight_ix }),
  };
  return ConvolutionBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, dilation, grad_output, groups, input, output_padding, padding, stride, transposed, weight);
}

void ConvolutionBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dilation);
    args.collect(grad_output_, false);
    args.collect(groups);
    args.collect(input_, false);
    args.collect(output_padding);
    args.collect(padding);
    args.collect(stride);
    args.collect(transposed);
    args.collect(weight_, false);
}
variable_list ConvolutionBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dilation);
  saved.before(grad_output_);
  saved.before(groups);
  saved.before(input_);
  saved.before(output_padding);
  saved.before(padding);
  saved.before(stride);
  saved.before(transposed);
  saved.before(weight_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ConvolutionBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto grad_output = grad_output_.unpack();
  auto input = input_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ weight_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dilation);
  packed_args.pack(grad_output);
  packed_args.pack(groups);
  packed_args.pack(input);
  packed_args.pack(output_padding);
  packed_args.pack(padding);
  packed_args.pack(stride);
  packed_args.pack(transposed);
  packed_args.pack(weight);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dilation);
  saved.after(grad_output_);
  saved.after(groups);
  saved.after(input_);
  saved.after(output_padding);
  saved.after(padding);
  saved.after(stride);
  saved.after(transposed);
  saved.after(weight_);
  return output_result;
#endif
}

static variable_list ConvolutionOverrideableBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, std::vector<c10::SymInt>& dilation, c10::SymInt& groups, Tensor& input, std::vector<c10::SymInt>& output_padding, std::vector<c10::SymInt>& padding, std::vector<c10::SymInt>& stride, bool& transposed, Tensor& weight)
{
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1] || needs_input_grad[2]) {
      auto grad_input_mask = std::array<bool, 3>{
        needs_input_grad[0],
        needs_input_grad[1],
        needs_input_grad[2],
      };
    auto grad_result = grad.defined() ? convolution_backward_overrideable_symint(grad, input, weight, stride, padding, dilation, transposed, output_padding, groups, grad_input_mask) : std::tuple<Tensor, Tensor, Tensor>();
      if (needs_input_grad[/*input*/0]) {
        copy_range(grad_inputs, input_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*weight*/1]) {
        copy_range(grad_inputs, weight_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*bias*/2]) {
        copy_range(grad_inputs, bias_ix, std::get<2>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list ConvolutionOverrideableBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto dilation = packed_args.unpack<std::vector<c10::SymInt>>();
  auto groups = packed_args.unpack<c10::SymInt>();
  auto input = packed_args.unpack<Tensor>();
  auto output_padding = packed_args.unpack<std::vector<c10::SymInt>>();
  auto padding = packed_args.unpack<std::vector<c10::SymInt>>();
  auto stride = packed_args.unpack<std::vector<c10::SymInt>>();
  auto transposed = packed_args.unpack<bool>();
  auto weight = packed_args.unpack<Tensor>();
  return ConvolutionOverrideableBackward0_apply_functional(variable_list(grads), needs_input_grad, dilation, groups, input, output_padding, padding, stride, transposed, weight);
#endif
}

variable_list ConvolutionOverrideableBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto input = input_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  return ConvolutionOverrideableBackward0_apply_functional(std::move(grads), needs_input_grad, dilation, groups, input, output_padding, padding, stride, transposed, weight);
}

void ConvolutionOverrideableBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dilation);
    args.collect(groups);
    args.collect(input_, false);
    args.collect(output_padding);
    args.collect(padding);
    args.collect(stride);
    args.collect(transposed);
    args.collect(weight_, false);
}
variable_list ConvolutionOverrideableBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dilation);
  saved.before(groups);
  saved.before(input_);
  saved.before(output_padding);
  saved.before(padding);
  saved.before(stride);
  saved.before(transposed);
  saved.before(weight_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ConvolutionOverrideableBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto input = input_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dilation);
  packed_args.pack(groups);
  packed_args.pack(input);
  packed_args.pack(output_padding);
  packed_args.pack(padding);
  packed_args.pack(stride);
  packed_args.pack(transposed);
  packed_args.pack(weight);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dilation);
  saved.after(groups);
  saved.after(input_);
  saved.after(output_padding);
  saved.after(padding);
  saved.after(stride);
  saved.after(transposed);
  saved.after(weight_);
  return output_result;
#endif
}

static variable_list ConvolutionBackwardOverrideableBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, std::vector<c10::SymInt>& dilation, Tensor& grad_output, c10::SymInt& groups, Tensor& input, std::vector<c10::SymInt>& output_padding, std::vector<c10::SymInt>& padding, std::vector<c10::SymInt>& stride, bool& transposed, Tensor& weight)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[0] || needs_input_grad[1] || needs_input_grad[2]) {
      auto grad_input_mask = std::array<bool, 3>{
        needs_input_grad[0],
        needs_input_grad[1],
        needs_input_grad[2],
      };
    auto grad_result = _convolution_double_backward_symint(grads[0], grads[1], grads[2], grad_output, weight, input, stride, padding, dilation, transposed, output_padding, groups, grad_input_mask);
      if (needs_input_grad[/*grad_output*/0]) {
        copy_range(grad_inputs, grad_output_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*input*/1]) {
        copy_range(grad_inputs, input_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*weight*/2]) {
        copy_range(grad_inputs, weight_ix, std::get<2>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list ConvolutionBackwardOverrideableBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto dilation = packed_args.unpack<std::vector<c10::SymInt>>();
  auto grad_output = packed_args.unpack<Tensor>();
  auto groups = packed_args.unpack<c10::SymInt>();
  auto input = packed_args.unpack<Tensor>();
  auto output_padding = packed_args.unpack<std::vector<c10::SymInt>>();
  auto padding = packed_args.unpack<std::vector<c10::SymInt>>();
  auto stride = packed_args.unpack<std::vector<c10::SymInt>>();
  auto transposed = packed_args.unpack<bool>();
  auto weight = packed_args.unpack<Tensor>();
  return ConvolutionBackwardOverrideableBackward0_apply_functional(variable_list(grads), needs_input_grad, dilation, grad_output, groups, input, output_padding, padding, stride, transposed, weight);
#endif
}

variable_list ConvolutionBackwardOverrideableBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto grad_output = grad_output_.unpack();
  auto input = input_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ weight_ix }),
  };
  return ConvolutionBackwardOverrideableBackward0_apply_functional(std::move(grads), needs_input_grad, dilation, grad_output, groups, input, output_padding, padding, stride, transposed, weight);
}

void ConvolutionBackwardOverrideableBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dilation);
    args.collect(grad_output_, false);
    args.collect(groups);
    args.collect(input_, false);
    args.collect(output_padding);
    args.collect(padding);
    args.collect(stride);
    args.collect(transposed);
    args.collect(weight_, false);
}
variable_list ConvolutionBackwardOverrideableBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dilation);
  saved.before(grad_output_);
  saved.before(groups);
  saved.before(input_);
  saved.before(output_padding);
  saved.before(padding);
  saved.before(stride);
  saved.before(transposed);
  saved.before(weight_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ConvolutionBackwardOverrideableBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto grad_output = grad_output_.unpack();
  auto input = input_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ weight_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dilation);
  packed_args.pack(grad_output);
  packed_args.pack(groups);
  packed_args.pack(input);
  packed_args.pack(output_padding);
  packed_args.pack(padding);
  packed_args.pack(stride);
  packed_args.pack(transposed);
  packed_args.pack(weight);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dilation);
  saved.after(grad_output_);
  saved.after(groups);
  saved.after(input_);
  saved.after(output_padding);
  saved.after(padding);
  saved.after(stride);
  saved.after(transposed);
  saved.after(weight_);
  return output_result;
#endif
}

static variable_list SlowConvTranspose2DBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, c10::OptionalArray<c10::SymInt>& bias_sym_sizes_opt, std::vector<c10::SymInt>& dilation, std::vector<c10::SymInt>& output_padding, std::vector<c10::SymInt>& padding, Tensor& self, std::vector<c10::SymInt>& stride, Tensor& weight)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1] || needs_input_grad[2]) {
      auto grad_input_mask = std::array<bool, 3>{
        needs_input_grad[0],
        needs_input_grad[1],
        needs_input_grad[2],
      };
    auto grad_result = grad.defined() ? convolution_backward_symint(grad, self, weight, bias_sym_sizes_opt, stride, padding, dilation, true, output_padding, 1, grad_input_mask) : std::tuple<Tensor, Tensor, Tensor>();
      if (needs_input_grad[/*self*/0]) {
        copy_range(grad_inputs, self_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*weight*/1]) {
        copy_range(grad_inputs, weight_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*bias*/2]) {
        copy_range(grad_inputs, bias_ix, std::get<2>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list SlowConvTranspose2DBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto bias_sym_sizes_opt = packed_args.unpack<c10::OptionalArray<c10::SymInt>>();
  auto dilation = packed_args.unpack<std::vector<c10::SymInt>>();
  auto output_padding = packed_args.unpack<std::vector<c10::SymInt>>();
  auto padding = packed_args.unpack<std::vector<c10::SymInt>>();
  auto self = packed_args.unpack<Tensor>();
  auto stride = packed_args.unpack<std::vector<c10::SymInt>>();
  auto weight = packed_args.unpack<Tensor>();
  return SlowConvTranspose2DBackward0_apply_functional(variable_list(grads), needs_input_grad, bias_sym_sizes_opt, dilation, output_padding, padding, self, stride, weight);
#endif
}

variable_list SlowConvTranspose2DBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  return SlowConvTranspose2DBackward0_apply_functional(std::move(grads), needs_input_grad, bias_sym_sizes_opt, dilation, output_padding, padding, self, stride, weight);
}

void SlowConvTranspose2DBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(bias_sym_sizes_opt);
    args.collect(dilation);
    args.collect(output_padding);
    args.collect(padding);
    args.collect(self_, false);
    args.collect(stride);
    args.collect(weight_, false);
}
variable_list SlowConvTranspose2DBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(bias_sym_sizes_opt);
  saved.before(dilation);
  saved.before(output_padding);
  saved.before(padding);
  saved.before(self_);
  saved.before(stride);
  saved.before(weight_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::OptionalArray<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SlowConvTranspose2DBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(bias_sym_sizes_opt);
  packed_args.pack(dilation);
  packed_args.pack(output_padding);
  packed_args.pack(padding);
  packed_args.pack(self);
  packed_args.pack(stride);
  packed_args.pack(weight);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(bias_sym_sizes_opt);
  saved.after(dilation);
  saved.after(output_padding);
  saved.after(padding);
  saved.after(self_);
  saved.after(stride);
  saved.after(weight_);
  return output_result;
#endif
}

static variable_list SlowConvTranspose3DBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, c10::OptionalArray<c10::SymInt>& bias_sym_sizes_opt, std::vector<c10::SymInt>& dilation, std::vector<c10::SymInt>& output_padding, std::vector<c10::SymInt>& padding, Tensor& self, std::vector<c10::SymInt>& stride, Tensor& weight)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1] || needs_input_grad[2]) {
      auto grad_input_mask = std::array<bool, 3>{
        needs_input_grad[0],
        needs_input_grad[1],
        needs_input_grad[2],
      };
    auto grad_result = grad.defined() ? convolution_backward_symint(grad, self, weight, bias_sym_sizes_opt, stride, padding, dilation, true, output_padding, 1, grad_input_mask) : std::tuple<Tensor, Tensor, Tensor>();
      if (needs_input_grad[/*self*/0]) {
        copy_range(grad_inputs, self_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*weight*/1]) {
        copy_range(grad_inputs, weight_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*bias*/2]) {
        copy_range(grad_inputs, bias_ix, std::get<2>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list SlowConvTranspose3DBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto bias_sym_sizes_opt = packed_args.unpack<c10::OptionalArray<c10::SymInt>>();
  auto dilation = packed_args.unpack<std::vector<c10::SymInt>>();
  auto output_padding = packed_args.unpack<std::vector<c10::SymInt>>();
  auto padding = packed_args.unpack<std::vector<c10::SymInt>>();
  auto self = packed_args.unpack<Tensor>();
  auto stride = packed_args.unpack<std::vector<c10::SymInt>>();
  auto weight = packed_args.unpack<Tensor>();
  return SlowConvTranspose3DBackward0_apply_functional(variable_list(grads), needs_input_grad, bias_sym_sizes_opt, dilation, output_padding, padding, self, stride, weight);
#endif
}

variable_list SlowConvTranspose3DBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  return SlowConvTranspose3DBackward0_apply_functional(std::move(grads), needs_input_grad, bias_sym_sizes_opt, dilation, output_padding, padding, self, stride, weight);
}

void SlowConvTranspose3DBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(bias_sym_sizes_opt);
    args.collect(dilation);
    args.collect(output_padding);
    args.collect(padding);
    args.collect(self_, false);
    args.collect(stride);
    args.collect(weight_, false);
}
variable_list SlowConvTranspose3DBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(bias_sym_sizes_opt);
  saved.before(dilation);
  saved.before(output_padding);
  saved.before(padding);
  saved.before(self_);
  saved.before(stride);
  saved.before(weight_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::OptionalArray<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SlowConvTranspose3DBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(bias_sym_sizes_opt);
  packed_args.pack(dilation);
  packed_args.pack(output_padding);
  packed_args.pack(padding);
  packed_args.pack(self);
  packed_args.pack(stride);
  packed_args.pack(weight);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(bias_sym_sizes_opt);
  saved.after(dilation);
  saved.after(output_padding);
  saved.after(padding);
  saved.after(self_);
  saved.after(stride);
  saved.after(weight_);
  return output_result;
#endif
}

static variable_list SlowConv2DBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, std::vector<c10::SymInt>& kernel_size, std::vector<c10::SymInt>& padding, Tensor& self, std::vector<c10::SymInt>& stride, Tensor& weight)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1] || needs_input_grad[2]) {
      auto grad_input_mask = std::array<bool, 3>{
        needs_input_grad[0],
        needs_input_grad[1],
        needs_input_grad[2],
      };
    auto grad_result = grad.defined() ? _slow_conv2d_backward_symint(grad, self, weight, kernel_size, stride, padding, grad_input_mask) : std::tuple<Tensor, Tensor, Tensor>();
      if (needs_input_grad[/*self*/0]) {
        copy_range(grad_inputs, self_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*weight*/1]) {
        copy_range(grad_inputs, weight_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*bias*/2]) {
        copy_range(grad_inputs, bias_ix, std::get<2>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list SlowConv2DBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto kernel_size = packed_args.unpack<std::vector<c10::SymInt>>();
  auto padding = packed_args.unpack<std::vector<c10::SymInt>>();
  auto self = packed_args.unpack<Tensor>();
  auto stride = packed_args.unpack<std::vector<c10::SymInt>>();
  auto weight = packed_args.unpack<Tensor>();
  return SlowConv2DBackward0_apply_functional(variable_list(grads), needs_input_grad, kernel_size, padding, self, stride, weight);
#endif
}

variable_list SlowConv2DBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  return SlowConv2DBackward0_apply_functional(std::move(grads), needs_input_grad, kernel_size, padding, self, stride, weight);
}

void SlowConv2DBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(kernel_size);
    args.collect(padding);
    args.collect(self_, false);
    args.collect(stride);
    args.collect(weight_, false);
}
variable_list SlowConv2DBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(kernel_size);
  saved.before(padding);
  saved.before(self_);
  saved.before(stride);
  saved.before(weight_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SlowConv2DBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(kernel_size);
  packed_args.pack(padding);
  packed_args.pack(self);
  packed_args.pack(stride);
  packed_args.pack(weight);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(kernel_size);
  saved.after(padding);
  saved.after(self_);
  saved.after(stride);
  saved.after(weight_);
  return output_result;
#endif
}

static variable_list SlowConv2DBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, Tensor& grad_output, std::vector<c10::SymInt>& padding, Tensor& self, std::vector<c10::SymInt>& stride, Tensor& weight)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[0] || needs_input_grad[1] || needs_input_grad[2]) {
      auto grad_input_mask = std::array<bool, 3>{
        needs_input_grad[0],
        needs_input_grad[1],
        needs_input_grad[2],
      };
    auto grad_result = _convolution_double_backward_symint(grads[0], grads[1], grads[2], grad_output, weight, self, stride, padding, {{1, 1}}, false, {{0, 0}}, 1, grad_input_mask);
      if (needs_input_grad[/*grad_output*/0]) {
        copy_range(grad_inputs, grad_output_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*self*/1]) {
        copy_range(grad_inputs, self_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*weight*/2]) {
        copy_range(grad_inputs, weight_ix, std::get<2>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list SlowConv2DBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto grad_output = packed_args.unpack<Tensor>();
  auto padding = packed_args.unpack<std::vector<c10::SymInt>>();
  auto self = packed_args.unpack<Tensor>();
  auto stride = packed_args.unpack<std::vector<c10::SymInt>>();
  auto weight = packed_args.unpack<Tensor>();
  return SlowConv2DBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, grad_output, padding, self, stride, weight);
#endif
}

variable_list SlowConv2DBackwardBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto grad_output = grad_output_.unpack();
  auto self = self_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ weight_ix }),
  };
  return SlowConv2DBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, grad_output, padding, self, stride, weight);
}

void SlowConv2DBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(grad_output_, false);
    args.collect(padding);
    args.collect(self_, false);
    args.collect(stride);
    args.collect(weight_, false);
}
variable_list SlowConv2DBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(grad_output_);
  saved.before(padding);
  saved.before(self_);
  saved.before(stride);
  saved.before(weight_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SlowConv2DBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto grad_output = grad_output_.unpack();
  auto self = self_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ weight_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(grad_output);
  packed_args.pack(padding);
  packed_args.pack(self);
  packed_args.pack(stride);
  packed_args.pack(weight);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(grad_output_);
  saved.after(padding);
  saved.after(self_);
  saved.after(stride);
  saved.after(weight_);
  return output_result;
#endif
}

static variable_list ConvDepthwise2DBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, c10::OptionalArray<c10::SymInt>& bias_sym_sizes_opt, std::vector<c10::SymInt>& dilation, std::vector<c10::SymInt>& padding, Tensor& self, std::vector<c10::SymInt>& stride, Tensor& weight)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1] || needs_input_grad[2]) {
      auto grad_input_mask = std::array<bool, 3>{
        needs_input_grad[0],
        needs_input_grad[1],
        needs_input_grad[2],
      };
    auto grad_result = grad.defined() ? convolution_backward_symint(grad.contiguous(), self, weight, bias_sym_sizes_opt, stride, padding, dilation, /*transposed=*/ false, /*output_padding=*/ {{0, 0}}, /*groups=*/ 1, grad_input_mask) : std::tuple<Tensor, Tensor, Tensor>();
      if (needs_input_grad[/*self*/0]) {
        copy_range(grad_inputs, self_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*weight*/1]) {
        copy_range(grad_inputs, weight_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*bias*/2]) {
        copy_range(grad_inputs, bias_ix, std::get<2>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list ConvDepthwise2DBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto bias_sym_sizes_opt = packed_args.unpack<c10::OptionalArray<c10::SymInt>>();
  auto dilation = packed_args.unpack<std::vector<c10::SymInt>>();
  auto padding = packed_args.unpack<std::vector<c10::SymInt>>();
  auto self = packed_args.unpack<Tensor>();
  auto stride = packed_args.unpack<std::vector<c10::SymInt>>();
  auto weight = packed_args.unpack<Tensor>();
  return ConvDepthwise2DBackward0_apply_functional(variable_list(grads), needs_input_grad, bias_sym_sizes_opt, dilation, padding, self, stride, weight);
#endif
}

variable_list ConvDepthwise2DBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  return ConvDepthwise2DBackward0_apply_functional(std::move(grads), needs_input_grad, bias_sym_sizes_opt, dilation, padding, self, stride, weight);
}

void ConvDepthwise2DBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(bias_sym_sizes_opt);
    args.collect(dilation);
    args.collect(padding);
    args.collect(self_, false);
    args.collect(stride);
    args.collect(weight_, false);
}
variable_list ConvDepthwise2DBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(bias_sym_sizes_opt);
  saved.before(dilation);
  saved.before(padding);
  saved.before(self_);
  saved.before(stride);
  saved.before(weight_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::OptionalArray<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ConvDepthwise2DBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(bias_sym_sizes_opt);
  packed_args.pack(dilation);
  packed_args.pack(padding);
  packed_args.pack(self);
  packed_args.pack(stride);
  packed_args.pack(weight);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(bias_sym_sizes_opt);
  saved.after(dilation);
  saved.after(padding);
  saved.after(self_);
  saved.after(stride);
  saved.after(weight_);
  return output_result;
#endif
}

static variable_list ConvDepthwise3DBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, c10::OptionalArray<c10::SymInt>& bias_sym_sizes_opt, std::vector<c10::SymInt>& dilation, std::vector<c10::SymInt>& padding, Tensor& self, std::vector<c10::SymInt>& stride, Tensor& weight)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1] || needs_input_grad[2]) {
      auto grad_input_mask = std::array<bool, 3>{
        needs_input_grad[0],
        needs_input_grad[1],
        needs_input_grad[2],
      };
    auto grad_result = grad.defined() ? convolution_backward_symint(grad.contiguous(), self, weight, bias_sym_sizes_opt, stride, padding, dilation, /*transposed=*/ false, /*output_padding=*/ {{0, 0, 0}}, /*groups=*/ 1, grad_input_mask) : std::tuple<Tensor, Tensor, Tensor>();
      if (needs_input_grad[/*self*/0]) {
        copy_range(grad_inputs, self_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*weight*/1]) {
        copy_range(grad_inputs, weight_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*bias*/2]) {
        copy_range(grad_inputs, bias_ix, std::get<2>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list ConvDepthwise3DBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto bias_sym_sizes_opt = packed_args.unpack<c10::OptionalArray<c10::SymInt>>();
  auto dilation = packed_args.unpack<std::vector<c10::SymInt>>();
  auto padding = packed_args.unpack<std::vector<c10::SymInt>>();
  auto self = packed_args.unpack<Tensor>();
  auto stride = packed_args.unpack<std::vector<c10::SymInt>>();
  auto weight = packed_args.unpack<Tensor>();
  return ConvDepthwise3DBackward0_apply_functional(variable_list(grads), needs_input_grad, bias_sym_sizes_opt, dilation, padding, self, stride, weight);
#endif
}

variable_list ConvDepthwise3DBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  return ConvDepthwise3DBackward0_apply_functional(std::move(grads), needs_input_grad, bias_sym_sizes_opt, dilation, padding, self, stride, weight);
}

void ConvDepthwise3DBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(bias_sym_sizes_opt);
    args.collect(dilation);
    args.collect(padding);
    args.collect(self_, false);
    args.collect(stride);
    args.collect(weight_, false);
}
variable_list ConvDepthwise3DBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(bias_sym_sizes_opt);
  saved.before(dilation);
  saved.before(padding);
  saved.before(self_);
  saved.before(stride);
  saved.before(weight_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::OptionalArray<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ConvDepthwise3DBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(bias_sym_sizes_opt);
  packed_args.pack(dilation);
  packed_args.pack(padding);
  packed_args.pack(self);
  packed_args.pack(stride);
  packed_args.pack(weight);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(bias_sym_sizes_opt);
  saved.after(dilation);
  saved.after(padding);
  saved.after(self_);
  saved.after(stride);
  saved.after(weight_);
  return output_result;
#endif
}

static variable_list SlowConv3DBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, c10::OptionalArray<c10::SymInt>& bias_sym_sizes_opt, std::vector<c10::SymInt>& padding, Tensor& self, std::vector<c10::SymInt>& stride, Tensor& weight)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1] || needs_input_grad[2]) {
      auto grad_input_mask = std::array<bool, 3>{
        needs_input_grad[0],
        needs_input_grad[1],
        needs_input_grad[2],
      };
    auto grad_result = grad.defined() ? convolution_backward_symint(grad, self, weight, bias_sym_sizes_opt, stride, padding, /*dilation=*/ {{1, 1, 1}}, false, /*output_padding=*/ {{0, 0, 0}}, 1, grad_input_mask) : std::tuple<Tensor, Tensor, Tensor>();
      if (needs_input_grad[/*self*/0]) {
        copy_range(grad_inputs, self_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*weight*/1]) {
        copy_range(grad_inputs, weight_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*bias*/2]) {
        copy_range(grad_inputs, bias_ix, std::get<2>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list SlowConv3DBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto bias_sym_sizes_opt = packed_args.unpack<c10::OptionalArray<c10::SymInt>>();
  auto padding = packed_args.unpack<std::vector<c10::SymInt>>();
  auto self = packed_args.unpack<Tensor>();
  auto stride = packed_args.unpack<std::vector<c10::SymInt>>();
  auto weight = packed_args.unpack<Tensor>();
  return SlowConv3DBackward0_apply_functional(variable_list(grads), needs_input_grad, bias_sym_sizes_opt, padding, self, stride, weight);
#endif
}

variable_list SlowConv3DBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  return SlowConv3DBackward0_apply_functional(std::move(grads), needs_input_grad, bias_sym_sizes_opt, padding, self, stride, weight);
}

void SlowConv3DBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(bias_sym_sizes_opt);
    args.collect(padding);
    args.collect(self_, false);
    args.collect(stride);
    args.collect(weight_, false);
}
variable_list SlowConv3DBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(bias_sym_sizes_opt);
  saved.before(padding);
  saved.before(self_);
  saved.before(stride);
  saved.before(weight_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::OptionalArray<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SlowConv3DBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(bias_sym_sizes_opt);
  packed_args.pack(padding);
  packed_args.pack(self);
  packed_args.pack(stride);
  packed_args.pack(weight);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(bias_sym_sizes_opt);
  saved.after(padding);
  saved.after(self_);
  saved.after(stride);
  saved.after(weight_);
  return output_result;
#endif
}

static variable_list SlowConvDilated2DBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, c10::OptionalArray<c10::SymInt>& bias_sym_sizes_opt, std::vector<c10::SymInt>& dilation, std::vector<c10::SymInt>& padding, Tensor& self, std::vector<c10::SymInt>& stride, Tensor& weight)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1] || needs_input_grad[2]) {
      auto grad_input_mask = std::array<bool, 3>{
        needs_input_grad[0],
        needs_input_grad[1],
        needs_input_grad[2],
      };
    auto grad_result = grad.defined() ? convolution_backward_symint(grad, self, weight, bias_sym_sizes_opt, stride, padding, dilation, false, std::vector<c10::SymInt>(padding.size(), 0), 1, grad_input_mask) : std::tuple<Tensor, Tensor, Tensor>();
      if (needs_input_grad[/*self*/0]) {
        copy_range(grad_inputs, self_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*weight*/1]) {
        copy_range(grad_inputs, weight_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*bias*/2]) {
        copy_range(grad_inputs, bias_ix, std::get<2>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list SlowConvDilated2DBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto bias_sym_sizes_opt = packed_args.unpack<c10::OptionalArray<c10::SymInt>>();
  auto dilation = packed_args.unpack<std::vector<c10::SymInt>>();
  auto padding = packed_args.unpack<std::vector<c10::SymInt>>();
  auto self = packed_args.unpack<Tensor>();
  auto stride = packed_args.unpack<std::vector<c10::SymInt>>();
  auto weight = packed_args.unpack<Tensor>();
  return SlowConvDilated2DBackward0_apply_functional(variable_list(grads), needs_input_grad, bias_sym_sizes_opt, dilation, padding, self, stride, weight);
#endif
}

variable_list SlowConvDilated2DBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  return SlowConvDilated2DBackward0_apply_functional(std::move(grads), needs_input_grad, bias_sym_sizes_opt, dilation, padding, self, stride, weight);
}

void SlowConvDilated2DBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(bias_sym_sizes_opt);
    args.collect(dilation);
    args.collect(padding);
    args.collect(self_, false);
    args.collect(stride);
    args.collect(weight_, false);
}
variable_list SlowConvDilated2DBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(bias_sym_sizes_opt);
  saved.before(dilation);
  saved.before(padding);
  saved.before(self_);
  saved.before(stride);
  saved.before(weight_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::OptionalArray<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SlowConvDilated2DBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(bias_sym_sizes_opt);
  packed_args.pack(dilation);
  packed_args.pack(padding);
  packed_args.pack(self);
  packed_args.pack(stride);
  packed_args.pack(weight);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(bias_sym_sizes_opt);
  saved.after(dilation);
  saved.after(padding);
  saved.after(self_);
  saved.after(stride);
  saved.after(weight_);
  return output_result;
#endif
}

static variable_list SlowConvDilated3DBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, c10::OptionalArray<c10::SymInt>& bias_sym_sizes_opt, std::vector<c10::SymInt>& dilation, std::vector<c10::SymInt>& padding, Tensor& self, std::vector<c10::SymInt>& stride, Tensor& weight)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1] || needs_input_grad[2]) {
      auto grad_input_mask = std::array<bool, 3>{
        needs_input_grad[0],
        needs_input_grad[1],
        needs_input_grad[2],
      };
    auto grad_result = grad.defined() ? convolution_backward_symint(grad, self, weight, bias_sym_sizes_opt, stride, padding, dilation, false, std::vector<c10::SymInt>(padding.size(), 0), 1, grad_input_mask) : std::tuple<Tensor, Tensor, Tensor>();
      if (needs_input_grad[/*self*/0]) {
        copy_range(grad_inputs, self_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*weight*/1]) {
        copy_range(grad_inputs, weight_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*bias*/2]) {
        copy_range(grad_inputs, bias_ix, std::get<2>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list SlowConvDilated3DBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto bias_sym_sizes_opt = packed_args.unpack<c10::OptionalArray<c10::SymInt>>();
  auto dilation = packed_args.unpack<std::vector<c10::SymInt>>();
  auto padding = packed_args.unpack<std::vector<c10::SymInt>>();
  auto self = packed_args.unpack<Tensor>();
  auto stride = packed_args.unpack<std::vector<c10::SymInt>>();
  auto weight = packed_args.unpack<Tensor>();
  return SlowConvDilated3DBackward0_apply_functional(variable_list(grads), needs_input_grad, bias_sym_sizes_opt, dilation, padding, self, stride, weight);
#endif
}

variable_list SlowConvDilated3DBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  return SlowConvDilated3DBackward0_apply_functional(std::move(grads), needs_input_grad, bias_sym_sizes_opt, dilation, padding, self, stride, weight);
}

void SlowConvDilated3DBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(bias_sym_sizes_opt);
    args.collect(dilation);
    args.collect(padding);
    args.collect(self_, false);
    args.collect(stride);
    args.collect(weight_, false);
}
variable_list SlowConvDilated3DBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(bias_sym_sizes_opt);
  saved.before(dilation);
  saved.before(padding);
  saved.before(self_);
  saved.before(stride);
  saved.before(weight_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::OptionalArray<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SlowConvDilated3DBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(bias_sym_sizes_opt);
  packed_args.pack(dilation);
  packed_args.pack(padding);
  packed_args.pack(self);
  packed_args.pack(stride);
  packed_args.pack(weight);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(bias_sym_sizes_opt);
  saved.after(dilation);
  saved.after(padding);
  saved.after(self_);
  saved.after(stride);
  saved.after(weight_);
  return output_result;
#endif
}

static variable_list Col2ImBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<int64_t>& dilation, std::vector<int64_t>& kernel_size, std::vector<int64_t>& padding, std::vector<int64_t>& stride)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (im2col(grad, kernel_size, dilation, padding, stride)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list Col2ImBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dilation = packed_args.unpack<std::vector<int64_t>>();
  auto kernel_size = packed_args.unpack<std::vector<int64_t>>();
  auto padding = packed_args.unpack<std::vector<int64_t>>();
  auto stride = packed_args.unpack<std::vector<int64_t>>();
  return Col2ImBackward0_apply_functional(variable_list(grads), needs_input_grad, dilation, kernel_size, padding, stride);
#endif
}

variable_list Col2ImBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return Col2ImBackward0_apply_functional(std::move(grads), needs_input_grad, dilation, kernel_size, padding, stride);
}

void Col2ImBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dilation);
    args.collect(kernel_size);
    args.collect(padding);
    args.collect(stride);
}
variable_list Col2ImBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dilation);
  saved.before(kernel_size);
  saved.before(padding);
  saved.before(stride);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), Col2ImBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dilation);
  packed_args.pack(kernel_size);
  packed_args.pack(padding);
  packed_args.pack(stride);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dilation);
  saved.after(kernel_size);
  saved.after(padding);
  saved.after(stride);
  return output_result;
#endif
}

static variable_list Im2ColBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<int64_t>& dilation, std::vector<int64_t>& kernel_size, std::vector<int64_t>& padding, c10::SymInt& self_sym_argsize_minus_1, c10::SymInt& self_sym_argsize_minus_2, std::vector<int64_t>& stride)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (col2im_symint(grad, {self_sym_argsize_minus_2, self_sym_argsize_minus_1}, kernel_size, dilation, padding, stride)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list Im2ColBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dilation = packed_args.unpack<std::vector<int64_t>>();
  auto kernel_size = packed_args.unpack<std::vector<int64_t>>();
  auto padding = packed_args.unpack<std::vector<int64_t>>();
  auto self_sym_argsize_minus_1 = packed_args.unpack<c10::SymInt>();
  auto self_sym_argsize_minus_2 = packed_args.unpack<c10::SymInt>();
  auto stride = packed_args.unpack<std::vector<int64_t>>();
  return Im2ColBackward0_apply_functional(variable_list(grads), needs_input_grad, dilation, kernel_size, padding, self_sym_argsize_minus_1, self_sym_argsize_minus_2, stride);
#endif
}

variable_list Im2ColBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return Im2ColBackward0_apply_functional(std::move(grads), needs_input_grad, dilation, kernel_size, padding, self_sym_argsize_minus_1, self_sym_argsize_minus_2, stride);
}

void Im2ColBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dilation);
    args.collect(kernel_size);
    args.collect(padding);
    args.collect(self_sym_argsize_minus_1);
    args.collect(self_sym_argsize_minus_2);
    args.collect(stride);
}
variable_list Im2ColBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dilation);
  saved.before(kernel_size);
  saved.before(padding);
  saved.before(self_sym_argsize_minus_1);
  saved.before(self_sym_argsize_minus_2);
  saved.before(stride);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), Im2ColBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dilation);
  packed_args.pack(kernel_size);
  packed_args.pack(padding);
  packed_args.pack(self_sym_argsize_minus_1);
  packed_args.pack(self_sym_argsize_minus_2);
  packed_args.pack(stride);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dilation);
  saved.after(kernel_size);
  saved.after(padding);
  saved.after(self_sym_argsize_minus_1);
  saved.after(self_sym_argsize_minus_2);
  saved.after(stride);
  return output_result;
#endif
}

static variable_list AdaptiveAvgPool2DBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, c10::SymInt& grad_output_sym_argsize_minus_1, c10::SymInt& grad_output_sym_argsize_minus_2, torch::autograd::generated::TypeAndSize& self_info)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (_adaptive_avg_pool2d_symint(grad, {grad_output_sym_argsize_minus_2, grad_output_sym_argsize_minus_1})) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  if (needs_input_grad[/*self*/1]) {
    auto grad_result = any_grad_defined ? (self_info.zeros()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list AdaptiveAvgPool2DBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto grad_output_sym_argsize_minus_1 = packed_args.unpack<c10::SymInt>();
  auto grad_output_sym_argsize_minus_2 = packed_args.unpack<c10::SymInt>();
  auto self_info = packed_args.unpack<torch::autograd::generated::TypeAndSize>();
  return AdaptiveAvgPool2DBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, grad_output_sym_argsize_minus_1, grad_output_sym_argsize_minus_2, self_info);
#endif
}

variable_list AdaptiveAvgPool2DBackwardBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  return AdaptiveAvgPool2DBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, grad_output_sym_argsize_minus_1, grad_output_sym_argsize_minus_2, self_info);
}

void AdaptiveAvgPool2DBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(grad_output_sym_argsize_minus_1);
    args.collect(grad_output_sym_argsize_minus_2);
    args.collect(self_info);
}
variable_list AdaptiveAvgPool2DBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(grad_output_sym_argsize_minus_1);
  saved.before(grad_output_sym_argsize_minus_2);
  saved.before(self_info);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::autograd::generated::TypeAndSize>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), AdaptiveAvgPool2DBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(grad_output_sym_argsize_minus_1);
  packed_args.pack(grad_output_sym_argsize_minus_2);
  packed_args.pack(self_info);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(grad_output_sym_argsize_minus_1);
  saved.after(grad_output_sym_argsize_minus_2);
  saved.after(self_info);
  return output_result;
#endif
}

static variable_list AdaptiveAvgPool3DBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, c10::SymInt& grad_output_sym_argsize_minus_1, c10::SymInt& grad_output_sym_argsize_minus_2, c10::SymInt& grad_output_sym_argsize_minus_3, torch::autograd::generated::TypeAndSize& self_info)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (_adaptive_avg_pool3d_symint(grad, { grad_output_sym_argsize_minus_3, grad_output_sym_argsize_minus_2, grad_output_sym_argsize_minus_1 })) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  if (needs_input_grad[/*self*/1]) {
    auto grad_result = any_grad_defined ? (self_info.zeros()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list AdaptiveAvgPool3DBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto grad_output_sym_argsize_minus_1 = packed_args.unpack<c10::SymInt>();
  auto grad_output_sym_argsize_minus_2 = packed_args.unpack<c10::SymInt>();
  auto grad_output_sym_argsize_minus_3 = packed_args.unpack<c10::SymInt>();
  auto self_info = packed_args.unpack<torch::autograd::generated::TypeAndSize>();
  return AdaptiveAvgPool3DBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, grad_output_sym_argsize_minus_1, grad_output_sym_argsize_minus_2, grad_output_sym_argsize_minus_3, self_info);
#endif
}

variable_list AdaptiveAvgPool3DBackwardBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  return AdaptiveAvgPool3DBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, grad_output_sym_argsize_minus_1, grad_output_sym_argsize_minus_2, grad_output_sym_argsize_minus_3, self_info);
}

void AdaptiveAvgPool3DBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(grad_output_sym_argsize_minus_1);
    args.collect(grad_output_sym_argsize_minus_2);
    args.collect(grad_output_sym_argsize_minus_3);
    args.collect(self_info);
}
variable_list AdaptiveAvgPool3DBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(grad_output_sym_argsize_minus_1);
  saved.before(grad_output_sym_argsize_minus_2);
  saved.before(grad_output_sym_argsize_minus_3);
  saved.before(self_info);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::autograd::generated::TypeAndSize>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), AdaptiveAvgPool3DBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(grad_output_sym_argsize_minus_1);
  packed_args.pack(grad_output_sym_argsize_minus_2);
  packed_args.pack(grad_output_sym_argsize_minus_3);
  packed_args.pack(self_info);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(grad_output_sym_argsize_minus_1);
  saved.after(grad_output_sym_argsize_minus_2);
  saved.after(grad_output_sym_argsize_minus_3);
  saved.after(self_info);
  return output_result;
#endif
}

static variable_list AdaptiveMaxPool2DBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& indices, torch::autograd::generated::TypeAndSize& self_info)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (max_pool_double_backward(grad, indices, 2)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  if (needs_input_grad[/*self*/1]) {
    auto grad_result = any_grad_defined ? (self_info.zeros()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list AdaptiveMaxPool2DBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto indices = packed_args.unpack<Tensor>();
  auto self_info = packed_args.unpack<torch::autograd::generated::TypeAndSize>();
  return AdaptiveMaxPool2DBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, indices, self_info);
#endif
}

variable_list AdaptiveMaxPool2DBackwardBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto indices = indices_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  return AdaptiveMaxPool2DBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, indices, self_info);
}

void AdaptiveMaxPool2DBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(indices_, false);
    args.collect(self_info);
}
variable_list AdaptiveMaxPool2DBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(indices_);
  saved.before(self_info);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::autograd::generated::TypeAndSize>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), AdaptiveMaxPool2DBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto indices = indices_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(indices);
  packed_args.pack(self_info);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(indices_);
  saved.after(self_info);
  return output_result;
#endif
}

static variable_list AdaptiveMaxPool3DBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& indices, torch::autograd::generated::TypeAndSize& self_info)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (max_pool_double_backward(grad, indices, 3)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  if (needs_input_grad[/*self*/1]) {
    auto grad_result = any_grad_defined ? (self_info.zeros()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list AdaptiveMaxPool3DBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto indices = packed_args.unpack<Tensor>();
  auto self_info = packed_args.unpack<torch::autograd::generated::TypeAndSize>();
  return AdaptiveMaxPool3DBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, indices, self_info);
#endif
}

variable_list AdaptiveMaxPool3DBackwardBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto indices = indices_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  return AdaptiveMaxPool3DBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, indices, self_info);
}

void AdaptiveMaxPool3DBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(indices_, false);
    args.collect(self_info);
}
variable_list AdaptiveMaxPool3DBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(indices_);
  saved.before(self_info);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::autograd::generated::TypeAndSize>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), AdaptiveMaxPool3DBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto indices = indices_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(indices);
  packed_args.pack(self_info);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(indices_);
  saved.after(self_info);
  return output_result;
#endif
}

static variable_list AvgPool2DBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, bool& ceil_mode, bool& count_include_pad, ::std::optional<int64_t>& divisor_override, std::vector<int64_t>& kernel_size, std::vector<int64_t>& padding, torch::autograd::generated::TypeAndSize& self_info, std::vector<int64_t>& stride)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (avg_pool2d(grad, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  if (needs_input_grad[/*self*/1]) {
    auto grad_result = any_grad_defined ? (self_info.zeros()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list AvgPool2DBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto ceil_mode = packed_args.unpack<bool>();
  auto count_include_pad = packed_args.unpack<bool>();
  auto divisor_override = packed_args.unpack<::std::optional<int64_t>>();
  auto kernel_size = packed_args.unpack<std::vector<int64_t>>();
  auto padding = packed_args.unpack<std::vector<int64_t>>();
  auto self_info = packed_args.unpack<torch::autograd::generated::TypeAndSize>();
  auto stride = packed_args.unpack<std::vector<int64_t>>();
  return AvgPool2DBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, ceil_mode, count_include_pad, divisor_override, kernel_size, padding, self_info, stride);
#endif
}

variable_list AvgPool2DBackwardBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  return AvgPool2DBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, ceil_mode, count_include_pad, divisor_override, kernel_size, padding, self_info, stride);
}

void AvgPool2DBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(ceil_mode);
    args.collect(count_include_pad);
    args.collect(divisor_override);
    args.collect(kernel_size);
    args.collect(padding);
    args.collect(self_info);
    args.collect(stride);
}
variable_list AvgPool2DBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(ceil_mode);
  saved.before(count_include_pad);
  saved.before(divisor_override);
  saved.before(kernel_size);
  saved.before(padding);
  saved.before(self_info);
  saved.before(stride);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::autograd::generated::TypeAndSize>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), AvgPool2DBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(ceil_mode);
  packed_args.pack(count_include_pad);
  packed_args.pack(divisor_override);
  packed_args.pack(kernel_size);
  packed_args.pack(padding);
  packed_args.pack(self_info);
  packed_args.pack(stride);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(ceil_mode);
  saved.after(count_include_pad);
  saved.after(divisor_override);
  saved.after(kernel_size);
  saved.after(padding);
  saved.after(self_info);
  saved.after(stride);
  return output_result;
#endif
}

static variable_list AvgPool3DBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, bool& ceil_mode, bool& count_include_pad, ::std::optional<int64_t>& divisor_override, std::vector<int64_t>& kernel_size, std::vector<int64_t>& padding, torch::autograd::generated::TypeAndSize& self_info, std::vector<int64_t>& stride)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (avg_pool3d(grad, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  if (needs_input_grad[/*self*/1]) {
    auto grad_result = any_grad_defined ? (self_info.zeros()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list AvgPool3DBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto ceil_mode = packed_args.unpack<bool>();
  auto count_include_pad = packed_args.unpack<bool>();
  auto divisor_override = packed_args.unpack<::std::optional<int64_t>>();
  auto kernel_size = packed_args.unpack<std::vector<int64_t>>();
  auto padding = packed_args.unpack<std::vector<int64_t>>();
  auto self_info = packed_args.unpack<torch::autograd::generated::TypeAndSize>();
  auto stride = packed_args.unpack<std::vector<int64_t>>();
  return AvgPool3DBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, ceil_mode, count_include_pad, divisor_override, kernel_size, padding, self_info, stride);
#endif
}

variable_list AvgPool3DBackwardBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  return AvgPool3DBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, ceil_mode, count_include_pad, divisor_override, kernel_size, padding, self_info, stride);
}

void AvgPool3DBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(ceil_mode);
    args.collect(count_include_pad);
    args.collect(divisor_override);
    args.collect(kernel_size);
    args.collect(padding);
    args.collect(self_info);
    args.collect(stride);
}
variable_list AvgPool3DBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(ceil_mode);
  saved.before(count_include_pad);
  saved.before(divisor_override);
  saved.before(kernel_size);
  saved.before(padding);
  saved.before(self_info);
  saved.before(stride);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::autograd::generated::TypeAndSize>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), AvgPool3DBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(ceil_mode);
  packed_args.pack(count_include_pad);
  packed_args.pack(divisor_override);
  packed_args.pack(kernel_size);
  packed_args.pack(padding);
  packed_args.pack(self_info);
  packed_args.pack(stride);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(ceil_mode);
  saved.after(count_include_pad);
  saved.after(divisor_override);
  saved.after(kernel_size);
  saved.after(padding);
  saved.after(self_info);
  saved.after(stride);
  return output_result;
#endif
}

static variable_list EluBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, at::Scalar& alpha, Tensor& grad_output, at::Scalar& input_scale, bool& is_result, at::Scalar& scale, Tensor& self_or_result)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_or_result_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (elu_backward(grad, alpha, scale, input_scale, is_result, self_or_result)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  if (needs_input_grad[/*self_or_result*/1]) {
    auto grad_result = any_grad_defined ? (elu_double_backward(grad, grad_output, alpha, scale, input_scale, is_result, self_or_result)) : Tensor();
    copy_range(grad_inputs, self_or_result_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list EluBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto alpha = packed_args.unpack<at::Scalar>();
  auto grad_output = packed_args.unpack<Tensor>();
  auto input_scale = packed_args.unpack<at::Scalar>();
  auto is_result = packed_args.unpack<bool>();
  auto scale = packed_args.unpack<at::Scalar>();
  auto self_or_result = packed_args.unpack<Tensor>();
  return EluBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, alpha, grad_output, input_scale, is_result, scale, self_or_result);
#endif
}

variable_list EluBackwardBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto grad_output = grad_output_.unpack();
  auto self_or_result = self_or_result_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_or_result_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_or_result_ix }),
  };
  return EluBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, alpha, grad_output, input_scale, is_result, scale, self_or_result);
}

void EluBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(alpha);
    args.collect(grad_output_, false);
    args.collect(input_scale);
    args.collect(is_result);
    args.collect(scale);
    args.collect(self_or_result_, false);
}
variable_list EluBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(alpha);
  saved.before(grad_output_);
  saved.before(input_scale);
  saved.before(is_result);
  saved.before(scale);
  saved.before(self_or_result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), EluBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto grad_output = grad_output_.unpack();
  auto self_or_result = self_or_result_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_or_result_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_or_result_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(alpha);
  packed_args.pack(grad_output);
  packed_args.pack(input_scale);
  packed_args.pack(is_result);
  packed_args.pack(scale);
  packed_args.pack(self_or_result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(alpha);
  saved.after(grad_output_);
  saved.after(input_scale);
  saved.after(is_result);
  saved.after(scale);
  saved.after(self_or_result_);
  return output_result;
#endif
}

static variable_list FractionalMaxPool2DBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& indices, torch::autograd::generated::TypeAndSize& self_info)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (max_pool_double_backward(grad, indices, 2)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  if (needs_input_grad[/*self*/1]) {
    auto grad_result = any_grad_defined ? (self_info.zeros()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list FractionalMaxPool2DBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto indices = packed_args.unpack<Tensor>();
  auto self_info = packed_args.unpack<torch::autograd::generated::TypeAndSize>();
  return FractionalMaxPool2DBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, indices, self_info);
#endif
}

variable_list FractionalMaxPool2DBackwardBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto indices = indices_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  return FractionalMaxPool2DBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, indices, self_info);
}

void FractionalMaxPool2DBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(indices_, false);
    args.collect(self_info);
}
variable_list FractionalMaxPool2DBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(indices_);
  saved.before(self_info);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::autograd::generated::TypeAndSize>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), FractionalMaxPool2DBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto indices = indices_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(indices);
  packed_args.pack(self_info);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(indices_);
  saved.after(self_info);
  return output_result;
#endif
}

static variable_list FractionalMaxPool3DBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& indices, torch::autograd::generated::TypeAndSize& self_info)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (max_pool_double_backward(grad, indices, 3)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  if (needs_input_grad[/*self*/1]) {
    auto grad_result = any_grad_defined ? (self_info.zeros()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list FractionalMaxPool3DBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto indices = packed_args.unpack<Tensor>();
  auto self_info = packed_args.unpack<torch::autograd::generated::TypeAndSize>();
  return FractionalMaxPool3DBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, indices, self_info);
#endif
}

variable_list FractionalMaxPool3DBackwardBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto indices = indices_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  return FractionalMaxPool3DBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, indices, self_info);
}

void FractionalMaxPool3DBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(indices_, false);
    args.collect(self_info);
}
variable_list FractionalMaxPool3DBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(indices_);
  saved.before(self_info);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::autograd::generated::TypeAndSize>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), FractionalMaxPool3DBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto indices = indices_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(indices);
  packed_args.pack(self_info);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(indices_);
  saved.after(self_info);
  return output_result;
#endif
}

static variable_list GluBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, int64_t& dim, Tensor& grad_output, Tensor& self)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (glu_double_backward_grad_output(grad, self, dim)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  if (needs_input_grad[/*self*/1]) {
    auto grad_result = any_grad_defined ? (glu_double_backward(grad, grad_output, self, dim)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list GluBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto dim = packed_args.unpack<int64_t>();
  auto grad_output = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<Tensor>();
  return GluBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, grad_output, self);
#endif
}

variable_list GluBackwardBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto grad_output = grad_output_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  return GluBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, dim, grad_output, self);
}

void GluBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(grad_output_, false);
    args.collect(self_, false);
}
variable_list GluBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(grad_output_);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), GluBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto grad_output = grad_output_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(grad_output);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(grad_output_);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list HardtanhBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, at::Scalar& max_val, at::Scalar& min_val, Tensor& self)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (hardtanh_backward(grad, self, min_val, max_val)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  if (needs_input_grad[/*self*/1]) {
    auto grad_result = any_grad_defined ? (zeros_like(grad)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list HardtanhBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto max_val = packed_args.unpack<at::Scalar>();
  auto min_val = packed_args.unpack<at::Scalar>();
  auto self = packed_args.unpack<Tensor>();
  return HardtanhBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, max_val, min_val, self);
#endif
}

variable_list HardtanhBackwardBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  return HardtanhBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, max_val, min_val, self);
}

void HardtanhBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(max_val);
    args.collect(min_val);
    args.collect(self_, false);
}
variable_list HardtanhBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(max_val);
  saved.before(min_val);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), HardtanhBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(max_val);
  packed_args.pack(min_val);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(max_val);
  saved.after(min_val);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list LogSigmoidBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& buffer, Tensor& grad_output, Tensor& self)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (log_sigmoid_backward(grad, self, buffer)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  if (needs_input_grad[/*self*/1]) {
    auto grad_result = any_grad_defined ? (log_sigmoid_double_backward(grad * grad_output, self)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list LogSigmoidBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto buffer = packed_args.unpack<Tensor>();
  auto grad_output = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<Tensor>();
  return LogSigmoidBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, buffer, grad_output, self);
#endif
}

variable_list LogSigmoidBackwardBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto buffer = buffer_.unpack();
  auto grad_output = grad_output_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  return LogSigmoidBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, buffer, grad_output, self);
}

void LogSigmoidBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(buffer_, false);
    args.collect(grad_output_, false);
    args.collect(self_, false);
}
variable_list LogSigmoidBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(buffer_);
  saved.before(grad_output_);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), LogSigmoidBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto buffer = buffer_.unpack();
  auto grad_output = grad_output_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(buffer);
  packed_args.pack(grad_output);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(buffer_);
  saved.after(grad_output_);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list LogSoftmaxBackwardDataBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, int64_t& dim, Tensor& grad_output, Tensor& output)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto output_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (grad.to(output.dtype()) - (grad.to(output.dtype()) * output.exp()).sum(dim, true)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  if (needs_input_grad[/*output*/1]) {
    auto grad_result = any_grad_defined ? ((-grad_output.sum(dim, true) * output.exp() * grad.to(output.dtype())).to(output.dtype())) : Tensor();
    copy_range(grad_inputs, output_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list LogSoftmaxBackwardDataBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto dim = packed_args.unpack<int64_t>();
  auto grad_output = packed_args.unpack<Tensor>();
  auto output = packed_args.unpack<Tensor>();
  return LogSoftmaxBackwardDataBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, grad_output, output);
#endif
}

variable_list LogSoftmaxBackwardDataBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto grad_output = grad_output_.unpack();
  auto output = output_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto output_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ output_ix }),
  };
  return LogSoftmaxBackwardDataBackward0_apply_functional(std::move(grads), needs_input_grad, dim, grad_output, output);
}

void LogSoftmaxBackwardDataBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(grad_output_, false);
    args.collect(output_, false);
}
variable_list LogSoftmaxBackwardDataBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(grad_output_);
  saved.before(output_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), LogSoftmaxBackwardDataBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto grad_output = grad_output_.unpack();
  auto output = output_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto output_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ output_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(grad_output);
  packed_args.pack(output);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(grad_output_);
  saved.after(output_);
  return output_result;
#endif
}

static variable_list LeakyReluBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, at::Scalar& negative_slope, Tensor& self)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (leaky_relu_backward(grad, self, negative_slope, false)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  if (needs_input_grad[/*self*/1]) {
    auto grad_result = any_grad_defined ? (zeros_like(grad)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list LeakyReluBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto negative_slope = packed_args.unpack<at::Scalar>();
  auto self = packed_args.unpack<Tensor>();
  return LeakyReluBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, negative_slope, self);
#endif
}

variable_list LeakyReluBackwardBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  return LeakyReluBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, negative_slope, self);
}

void LeakyReluBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(negative_slope);
    args.collect(self_, false);
}
variable_list LeakyReluBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(negative_slope);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), LeakyReluBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(negative_slope);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(negative_slope);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list MaxPool2DBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, torch::autograd::generated::TypeAndSize& self_info)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (error_for_max_pool2d_double_backward()) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  if (needs_input_grad[/*self*/1]) {
    auto grad_result = any_grad_defined ? (self_info.zeros()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list MaxPool2DBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto self_info = packed_args.unpack<torch::autograd::generated::TypeAndSize>();
  return MaxPool2DBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, self_info);
#endif
}

variable_list MaxPool2DBackwardBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  return MaxPool2DBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, self_info);
}

void MaxPool2DBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_info);
}
variable_list MaxPool2DBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_info);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::autograd::generated::TypeAndSize>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MaxPool2DBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_info);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_info);
  return output_result;
#endif
}

static variable_list MaxPool2DWithIndicesBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& indices, torch::autograd::generated::TypeAndSize& self_info)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (max_pool_double_backward(grad, indices, 2)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  if (needs_input_grad[/*self*/1]) {
    auto grad_result = any_grad_defined ? (self_info.zeros()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list MaxPool2DWithIndicesBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto indices = packed_args.unpack<Tensor>();
  auto self_info = packed_args.unpack<torch::autograd::generated::TypeAndSize>();
  return MaxPool2DWithIndicesBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, indices, self_info);
#endif
}

variable_list MaxPool2DWithIndicesBackwardBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto indices = indices_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  return MaxPool2DWithIndicesBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, indices, self_info);
}

void MaxPool2DWithIndicesBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(indices_, false);
    args.collect(self_info);
}
variable_list MaxPool2DWithIndicesBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(indices_);
  saved.before(self_info);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::autograd::generated::TypeAndSize>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MaxPool2DWithIndicesBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto indices = indices_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(indices);
  packed_args.pack(self_info);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(indices_);
  saved.after(self_info);
  return output_result;
#endif
}

static variable_list MaxPool3DWithIndicesBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& indices, torch::autograd::generated::TypeAndSize& self_info)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (max_pool_double_backward(grad, indices, 3)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  if (needs_input_grad[/*self*/1]) {
    auto grad_result = any_grad_defined ? (self_info.zeros()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list MaxPool3DWithIndicesBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto indices = packed_args.unpack<Tensor>();
  auto self_info = packed_args.unpack<torch::autograd::generated::TypeAndSize>();
  return MaxPool3DWithIndicesBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, indices, self_info);
#endif
}

variable_list MaxPool3DWithIndicesBackwardBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto indices = indices_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  return MaxPool3DWithIndicesBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, indices, self_info);
}

void MaxPool3DWithIndicesBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(indices_, false);
    args.collect(self_info);
}
variable_list MaxPool3DWithIndicesBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(indices_);
  saved.before(self_info);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::autograd::generated::TypeAndSize>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MaxPool3DWithIndicesBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto indices = indices_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(indices);
  packed_args.pack(self_info);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(indices_);
  saved.after(self_info);
  return output_result;
#endif
}

static variable_list MseLossBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, Tensor& grad_output, int64_t& reduction, Tensor& self, Tensor& target)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto target_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (mse_loss_backward(grad, self, target, reduction)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  if (needs_input_grad[/*self*/1]) {
    auto grad_result = any_grad_defined ? (mse_loss_double_backward(grad * grad_output, self, reduction)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  if (needs_input_grad[/*target*/2]) {
    auto grad_result = any_grad_defined ? (-mse_loss_double_backward(grad * grad_output, target, reduction)) : Tensor();
    copy_range(grad_inputs, target_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list MseLossBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto grad_output = packed_args.unpack<Tensor>();
  auto reduction = packed_args.unpack<int64_t>();
  auto self = packed_args.unpack<Tensor>();
  auto target = packed_args.unpack<Tensor>();
  return MseLossBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, grad_output, reduction, self, target);
#endif
}

variable_list MseLossBackwardBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto grad_output = grad_output_.unpack();
  auto self = self_.unpack();
  auto target = target_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto target_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ target_ix }),
  };
  return MseLossBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, grad_output, reduction, self, target);
}

void MseLossBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(grad_output_, false);
    args.collect(reduction);
    args.collect(self_, false);
    args.collect(target_, false);
}
variable_list MseLossBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(grad_output_);
  saved.before(reduction);
  saved.before(self_);
  saved.before(target_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MseLossBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto grad_output = grad_output_.unpack();
  auto self = self_.unpack();
  auto target = target_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto target_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ target_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(grad_output);
  packed_args.pack(reduction);
  packed_args.pack(self);
  packed_args.pack(target);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(grad_output_);
  saved.after(reduction);
  saved.after(self_);
  saved.after(target_);
  return output_result;
#endif
}

static variable_list NllLossBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, c10::SymInt& ignore_index, int64_t& reduction, Tensor& target, Tensor& weight)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (nll_loss_symint(grad, target, weight, reduction, ignore_index)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  if (needs_input_grad[/*self*/1]) {
    auto grad_result = any_grad_defined ? (zeros_like(grad)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list NllLossBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto ignore_index = packed_args.unpack<c10::SymInt>();
  auto reduction = packed_args.unpack<int64_t>();
  auto target = packed_args.unpack<Tensor>();
  auto weight = packed_args.unpack<Tensor>();
  return NllLossBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, ignore_index, reduction, target, weight);
#endif
}

variable_list NllLossBackwardBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto target = target_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  return NllLossBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, ignore_index, reduction, target, weight);
}

void NllLossBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(ignore_index);
    args.collect(reduction);
    args.collect(target_, false);
    args.collect(weight_, false);
}
variable_list NllLossBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(ignore_index);
  saved.before(reduction);
  saved.before(target_);
  saved.before(weight_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), NllLossBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto target = target_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(ignore_index);
  packed_args.pack(reduction);
  packed_args.pack(target);
  packed_args.pack(weight);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(ignore_index);
  saved.after(reduction);
  saved.after(target_);
  saved.after(weight_);
  return output_result;
#endif
}

static variable_list NllLoss2DBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, c10::SymInt& ignore_index, int64_t& reduction, Tensor& target, Tensor& weight)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (nll_loss2d_symint(grad, target, weight, reduction, ignore_index)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  if (needs_input_grad[/*self*/1]) {
    auto grad_result = any_grad_defined ? (zeros_like(grad)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list NllLoss2DBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto ignore_index = packed_args.unpack<c10::SymInt>();
  auto reduction = packed_args.unpack<int64_t>();
  auto target = packed_args.unpack<Tensor>();
  auto weight = packed_args.unpack<Tensor>();
  return NllLoss2DBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, ignore_index, reduction, target, weight);
#endif
}

variable_list NllLoss2DBackwardBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto target = target_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  return NllLoss2DBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, ignore_index, reduction, target, weight);
}

void NllLoss2DBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(ignore_index);
    args.collect(reduction);
    args.collect(target_, false);
    args.collect(weight_, false);
}
variable_list NllLoss2DBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(ignore_index);
  saved.before(reduction);
  saved.before(target_);
  saved.before(weight_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), NllLoss2DBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto target = target_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(ignore_index);
  packed_args.pack(reduction);
  packed_args.pack(target);
  packed_args.pack(weight);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(ignore_index);
  saved.after(reduction);
  saved.after(target_);
  saved.after(weight_);
  return output_result;
#endif
}

static variable_list RreluWithNoiseBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, at::Scalar& lower, Tensor& noise, Tensor& self, bool& training, at::Scalar& upper)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (rrelu_with_noise_backward(grad, self, noise, lower, upper, training, false)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  if (needs_input_grad[/*self*/1]) {
    auto grad_result = any_grad_defined ? (zeros_like(grad)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list RreluWithNoiseBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto lower = packed_args.unpack<at::Scalar>();
  auto noise = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<Tensor>();
  auto training = packed_args.unpack<bool>();
  auto upper = packed_args.unpack<at::Scalar>();
  return RreluWithNoiseBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, lower, noise, self, training, upper);
#endif
}

variable_list RreluWithNoiseBackwardBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto noise = noise_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  return RreluWithNoiseBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, lower, noise, self, training, upper);
}

void RreluWithNoiseBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(lower);
    args.collect(noise_, false);
    args.collect(self_, false);
    args.collect(training);
    args.collect(upper);
}
variable_list RreluWithNoiseBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(lower);
  saved.before(noise_);
  saved.before(self_);
  saved.before(training);
  saved.before(upper);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), RreluWithNoiseBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto noise = noise_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(lower);
  packed_args.pack(noise);
  packed_args.pack(self);
  packed_args.pack(training);
  packed_args.pack(upper);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(lower);
  saved.after(noise_);
  saved.after(self_);
  saved.after(training);
  saved.after(upper);
  return output_result;
#endif
}

static variable_list ReflectionPad1DBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, std::vector<c10::SymInt>& padding, torch::autograd::generated::TypeAndSize& self_info)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (reflection_pad1d_symint(grad, padding)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  if (needs_input_grad[/*self*/1]) {
    auto grad_result = any_grad_defined ? (self_info.zeros()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ReflectionPad1DBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto padding = packed_args.unpack<std::vector<c10::SymInt>>();
  auto self_info = packed_args.unpack<torch::autograd::generated::TypeAndSize>();
  return ReflectionPad1DBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, padding, self_info);
#endif
}

variable_list ReflectionPad1DBackwardBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  return ReflectionPad1DBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, padding, self_info);
}

void ReflectionPad1DBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(padding);
    args.collect(self_info);
}
variable_list ReflectionPad1DBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(padding);
  saved.before(self_info);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::autograd::generated::TypeAndSize>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ReflectionPad1DBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(padding);
  packed_args.pack(self_info);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(padding);
  saved.after(self_info);
  return output_result;
#endif
}

static variable_list ReflectionPad2DBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, std::vector<c10::SymInt>& padding, torch::autograd::generated::TypeAndSize& self_info)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (reflection_pad2d_symint(grad, padding)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  if (needs_input_grad[/*self*/1]) {
    auto grad_result = any_grad_defined ? (self_info.zeros()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ReflectionPad2DBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto padding = packed_args.unpack<std::vector<c10::SymInt>>();
  auto self_info = packed_args.unpack<torch::autograd::generated::TypeAndSize>();
  return ReflectionPad2DBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, padding, self_info);
#endif
}

variable_list ReflectionPad2DBackwardBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  return ReflectionPad2DBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, padding, self_info);
}

void ReflectionPad2DBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(padding);
    args.collect(self_info);
}
variable_list ReflectionPad2DBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(padding);
  saved.before(self_info);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::autograd::generated::TypeAndSize>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ReflectionPad2DBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(padding);
  packed_args.pack(self_info);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(padding);
  saved.after(self_info);
  return output_result;
#endif
}

static variable_list ReflectionPad3DBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, std::vector<c10::SymInt>& padding, torch::autograd::generated::TypeAndSize& self_info)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (reflection_pad3d_symint(grad, padding)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  if (needs_input_grad[/*self*/1]) {
    auto grad_result = any_grad_defined ? (self_info.zeros()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ReflectionPad3DBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto padding = packed_args.unpack<std::vector<c10::SymInt>>();
  auto self_info = packed_args.unpack<torch::autograd::generated::TypeAndSize>();
  return ReflectionPad3DBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, padding, self_info);
#endif
}

variable_list ReflectionPad3DBackwardBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  return ReflectionPad3DBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, padding, self_info);
}

void ReflectionPad3DBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(padding);
    args.collect(self_info);
}
variable_list ReflectionPad3DBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(padding);
  saved.before(self_info);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::autograd::generated::TypeAndSize>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ReflectionPad3DBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(padding);
  packed_args.pack(self_info);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(padding);
  saved.after(self_info);
  return output_result;
#endif
}

static variable_list ReplicationPad1DBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, std::vector<c10::SymInt>& padding, torch::autograd::generated::TypeAndSize& self_info)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (replication_pad1d_symint(grad, padding)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  if (needs_input_grad[/*self*/1]) {
    auto grad_result = any_grad_defined ? (self_info.zeros()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ReplicationPad1DBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto padding = packed_args.unpack<std::vector<c10::SymInt>>();
  auto self_info = packed_args.unpack<torch::autograd::generated::TypeAndSize>();
  return ReplicationPad1DBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, padding, self_info);
#endif
}

variable_list ReplicationPad1DBackwardBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  return ReplicationPad1DBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, padding, self_info);
}

void ReplicationPad1DBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(padding);
    args.collect(self_info);
}
variable_list ReplicationPad1DBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(padding);
  saved.before(self_info);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::autograd::generated::TypeAndSize>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ReplicationPad1DBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(padding);
  packed_args.pack(self_info);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(padding);
  saved.after(self_info);
  return output_result;
#endif
}

static variable_list ReplicationPad2DBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, std::vector<c10::SymInt>& padding, torch::autograd::generated::TypeAndSize& self_info)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (replication_pad2d_symint(grad, padding)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  if (needs_input_grad[/*self*/1]) {
    auto grad_result = any_grad_defined ? (self_info.zeros()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ReplicationPad2DBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto padding = packed_args.unpack<std::vector<c10::SymInt>>();
  auto self_info = packed_args.unpack<torch::autograd::generated::TypeAndSize>();
  return ReplicationPad2DBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, padding, self_info);
#endif
}

variable_list ReplicationPad2DBackwardBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  return ReplicationPad2DBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, padding, self_info);
}

void ReplicationPad2DBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(padding);
    args.collect(self_info);
}
variable_list ReplicationPad2DBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(padding);
  saved.before(self_info);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::autograd::generated::TypeAndSize>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ReplicationPad2DBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(padding);
  packed_args.pack(self_info);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(padding);
  saved.after(self_info);
  return output_result;
#endif
}

static variable_list ReplicationPad3DBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, std::vector<c10::SymInt>& padding, torch::autograd::generated::TypeAndSize& self_info)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (replication_pad3d_symint(grad, padding)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  if (needs_input_grad[/*self*/1]) {
    auto grad_result = any_grad_defined ? (self_info.zeros()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ReplicationPad3DBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto padding = packed_args.unpack<std::vector<c10::SymInt>>();
  auto self_info = packed_args.unpack<torch::autograd::generated::TypeAndSize>();
  return ReplicationPad3DBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, padding, self_info);
#endif
}

variable_list ReplicationPad3DBackwardBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  return ReplicationPad3DBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, padding, self_info);
}

void ReplicationPad3DBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(padding);
    args.collect(self_info);
}
variable_list ReplicationPad3DBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(padding);
  saved.before(self_info);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<torch::autograd::generated::TypeAndSize>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ReplicationPad3DBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(padding);
  packed_args.pack(self_info);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(padding);
  saved.after(self_info);
  return output_result;
#endif
}

static variable_list SparseSampledAddmmBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, at::Scalar& alpha, at::Scalar& beta, Tensor& mat1, Tensor& mat2, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto mat1_ix = gen.range(1);
  auto mat2_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1] || needs_input_grad[2]) {
      auto grad_input_mask = std::array<bool, 3>{
        needs_input_grad[0],
        needs_input_grad[1],
        needs_input_grad[2],
      };
    auto grad_result = sparse_sampled_addmm_backward(grad, self, wrap_opt_if(mat1, grad_input_mask[2]), wrap_opt_if(mat2, grad_input_mask[1]), alpha, beta, grad_input_mask);
      if (needs_input_grad[/*self*/0]) {
        copy_range(grad_inputs, self_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*mat1*/1]) {
        copy_range(grad_inputs, mat1_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*mat2*/2]) {
        copy_range(grad_inputs, mat2_ix, std::get<2>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list SparseSampledAddmmBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto alpha = packed_args.unpack<at::Scalar>();
  auto beta = packed_args.unpack<at::Scalar>();
  auto mat1 = packed_args.unpack<Tensor>();
  auto mat2 = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<Tensor>();
  return SparseSampledAddmmBackward0_apply_functional(variable_list(grads), needs_input_grad, alpha, beta, mat1, mat2, self);
#endif
}

variable_list SparseSampledAddmmBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto mat1 = mat1_.unpack();
  auto mat2 = mat2_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto mat1_ix = gen.range(1);
  auto mat2_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ mat1_ix }),
    task_should_compute_output({ mat2_ix }),
  };
  return SparseSampledAddmmBackward0_apply_functional(std::move(grads), needs_input_grad, alpha, beta, mat1, mat2, self);
}

void SparseSampledAddmmBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(alpha);
    args.collect(beta);
    args.collect(mat1_, false);
    args.collect(mat2_, false);
    args.collect(self_, false);
}
variable_list SparseSampledAddmmBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(alpha);
  saved.before(beta);
  saved.before(mat1_);
  saved.before(mat2_);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SparseSampledAddmmBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto mat1 = mat1_.unpack();
  auto mat2 = mat2_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto mat1_ix = gen.range(1);
  auto mat2_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ mat1_ix }),
    task_should_compute_output({ mat2_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(alpha);
  packed_args.pack(beta);
  packed_args.pack(mat1);
  packed_args.pack(mat2);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(alpha);
  saved.after(beta);
  saved.after(mat1_);
  saved.after(mat2_);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list SparseMmReduceImplBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& other, std::string& reduce, Tensor& self, Tensor& result1)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1]) {
      auto grad_input_mask = std::array<bool, 2>{
        needs_input_grad[0],
        needs_input_grad[1],
      };
    auto grad_result = grad.defined() ? _sparse_mm_reduce_impl_backward(self, grad, other, reduce, result1, grad_input_mask) :  std::tuple<Tensor, Tensor>();
      if (needs_input_grad[/*self*/0]) {
        copy_range(grad_inputs, self_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*other*/1]) {
        copy_range(grad_inputs, other_ix, std::get<1>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list SparseMmReduceImplBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto other = packed_args.unpack<Tensor>();
  auto reduce = packed_args.unpack<std::string>();
  auto self = packed_args.unpack<Tensor>();
  auto result1 = packed_args.unpack<Tensor>();
  return SparseMmReduceImplBackward0_apply_functional(variable_list(grads), needs_input_grad, other, reduce, self, result1);
#endif
}

variable_list SparseMmReduceImplBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto other = other_.unpack();
  auto self = self_.unpack();
  auto result1 = result1_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  return SparseMmReduceImplBackward0_apply_functional(std::move(grads), needs_input_grad, other, reduce, self, result1);
}

void SparseMmReduceImplBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(other_, false);
    args.collect(reduce);
    args.collect(self_, false);
    args.collect(result1_, true);
}
variable_list SparseMmReduceImplBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(other_);
  saved.before(reduce);
  saved.before(self_);
  saved.before(result1_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::string>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SparseMmReduceImplBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto other = other_.unpack();
  auto self = self_.unpack();
  auto result1 = result1_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(other);
  packed_args.pack(reduce);
  packed_args.pack(self);
  packed_args.pack(result1);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(other_);
  saved.after(reduce);
  saved.after(self_);
  saved.after(result1_);
  return output_result;
#endif
}

static variable_list SmoothL1LossBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, double& beta, Tensor& grad_output, int64_t& reduction, Tensor& self, Tensor& target)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto target_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (smooth_l1_loss_backward(grad, self, target, reduction, beta)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  if (needs_input_grad[/*self*/1]) {
    auto grad_result = any_grad_defined ? (smooth_l1_loss_double_backward(grad * grad_output, self, target, reduction, beta)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  if (needs_input_grad[/*target*/2]) {
    auto grad_result = any_grad_defined ? (-smooth_l1_loss_double_backward(grad * grad_output, self, target, reduction, beta)) : Tensor();
    copy_range(grad_inputs, target_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SmoothL1LossBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto beta = packed_args.unpack<double>();
  auto grad_output = packed_args.unpack<Tensor>();
  auto reduction = packed_args.unpack<int64_t>();
  auto self = packed_args.unpack<Tensor>();
  auto target = packed_args.unpack<Tensor>();
  return SmoothL1LossBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, beta, grad_output, reduction, self, target);
#endif
}

variable_list SmoothL1LossBackwardBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto grad_output = grad_output_.unpack();
  auto self = self_.unpack();
  auto target = target_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto target_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ target_ix }),
  };
  return SmoothL1LossBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, beta, grad_output, reduction, self, target);
}

void SmoothL1LossBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(beta);
    args.collect(grad_output_, false);
    args.collect(reduction);
    args.collect(self_, false);
    args.collect(target_, false);
}
variable_list SmoothL1LossBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(beta);
  saved.before(grad_output_);
  saved.before(reduction);
  saved.before(self_);
  saved.before(target_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<double>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SmoothL1LossBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto grad_output = grad_output_.unpack();
  auto self = self_.unpack();
  auto target = target_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto target_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ target_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(beta);
  packed_args.pack(grad_output);
  packed_args.pack(reduction);
  packed_args.pack(self);
  packed_args.pack(target);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(beta);
  saved.after(grad_output_);
  saved.after(reduction);
  saved.after(self_);
  saved.after(target_);
  return output_result;
#endif
}

static variable_list HuberLossBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, double& delta, Tensor& grad_output, int64_t& reduction, Tensor& self, Tensor& target)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto target_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (huber_loss_double_backward_grad_output(grad, grad_output, self, target, reduction, delta)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  if (needs_input_grad[/*self*/1]) {
    auto grad_result = any_grad_defined ? (huber_loss_double_backward(grad * grad_output, self, target, reduction, delta)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  if (needs_input_grad[/*target*/2]) {
    auto grad_result = any_grad_defined ? (-huber_loss_double_backward(grad * grad_output, self, target, reduction, delta)) : Tensor();
    copy_range(grad_inputs, target_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list HuberLossBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto delta = packed_args.unpack<double>();
  auto grad_output = packed_args.unpack<Tensor>();
  auto reduction = packed_args.unpack<int64_t>();
  auto self = packed_args.unpack<Tensor>();
  auto target = packed_args.unpack<Tensor>();
  return HuberLossBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, delta, grad_output, reduction, self, target);
#endif
}

variable_list HuberLossBackwardBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto grad_output = grad_output_.unpack();
  auto self = self_.unpack();
  auto target = target_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto target_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ target_ix }),
  };
  return HuberLossBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, delta, grad_output, reduction, self, target);
}

void HuberLossBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(delta);
    args.collect(grad_output_, false);
    args.collect(reduction);
    args.collect(self_, false);
    args.collect(target_, false);
}
variable_list HuberLossBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(delta);
  saved.before(grad_output_);
  saved.before(reduction);
  saved.before(self_);
  saved.before(target_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<double>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), HuberLossBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto grad_output = grad_output_.unpack();
  auto self = self_.unpack();
  auto target = target_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto target_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ target_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(delta);
  packed_args.pack(grad_output);
  packed_args.pack(reduction);
  packed_args.pack(self);
  packed_args.pack(target);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(delta);
  saved.after(grad_output_);
  saved.after(reduction);
  saved.after(self_);
  saved.after(target_);
  return output_result;
#endif
}

static variable_list SoftplusBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, at::Scalar& beta, Tensor& grad_output, Tensor& self, at::Scalar& threshold)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (softplus_backward(grad, self, beta, threshold)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  if (needs_input_grad[/*self*/1]) {
    auto grad_result = any_grad_defined ? (softplus_double_backward(grad * grad_output, self, beta, threshold)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SoftplusBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto beta = packed_args.unpack<at::Scalar>();
  auto grad_output = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<Tensor>();
  auto threshold = packed_args.unpack<at::Scalar>();
  return SoftplusBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, beta, grad_output, self, threshold);
#endif
}

variable_list SoftplusBackwardBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto grad_output = grad_output_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  return SoftplusBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, beta, grad_output, self, threshold);
}

void SoftplusBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(beta);
    args.collect(grad_output_, false);
    args.collect(self_, false);
    args.collect(threshold);
}
variable_list SoftplusBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(beta);
  saved.before(grad_output_);
  saved.before(self_);
  saved.before(threshold);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SoftplusBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto grad_output = grad_output_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(beta);
  packed_args.pack(grad_output);
  packed_args.pack(self);
  packed_args.pack(threshold);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(beta);
  saved.after(grad_output_);
  saved.after(self_);
  saved.after(threshold);
  return output_result;
#endif
}

static variable_list SoftmaxBackwardDataBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, int64_t& dim, Tensor& grad_output, at::ScalarType& input_dtype, Tensor& output)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto output_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (_softmax_backward_data(grad.to(output.dtype()), output, dim, input_dtype)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  if (needs_input_grad[/*output*/1]) {
    auto grad_result = any_grad_defined ? (softmax_double_backward(grad.to(output.dtype()), grad_output, dim, output).to(output.dtype())) : Tensor();
    copy_range(grad_inputs, output_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SoftmaxBackwardDataBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto dim = packed_args.unpack<int64_t>();
  auto grad_output = packed_args.unpack<Tensor>();
  auto input_dtype = packed_args.unpack<at::ScalarType>();
  auto output = packed_args.unpack<Tensor>();
  return SoftmaxBackwardDataBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, grad_output, input_dtype, output);
#endif
}

variable_list SoftmaxBackwardDataBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto grad_output = grad_output_.unpack();
  auto output = output_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto output_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ output_ix }),
  };
  return SoftmaxBackwardDataBackward0_apply_functional(std::move(grads), needs_input_grad, dim, grad_output, input_dtype, output);
}

void SoftmaxBackwardDataBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(grad_output_, false);
    args.collect(input_dtype);
    args.collect(output_, false);
}
variable_list SoftmaxBackwardDataBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(grad_output_);
  saved.before(input_dtype);
  saved.before(output_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::ScalarType>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SoftmaxBackwardDataBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto grad_output = grad_output_.unpack();
  auto output = output_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto output_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ output_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(grad_output);
  packed_args.pack(input_dtype);
  packed_args.pack(output);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(grad_output_);
  saved.after(input_dtype);
  saved.after(output_);
  return output_result;
#endif
}

static variable_list SoftMarginLossBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& grad_output, int64_t& reduction, Tensor& self, Tensor& target)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (soft_margin_loss_double_backward_grad_output(grad, grad_output, self, target, reduction)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  if (needs_input_grad[/*self*/1]) {
    auto grad_result = any_grad_defined ? (soft_margin_loss_double_backward(grad * grad_output, self, target, reduction)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SoftMarginLossBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto grad_output = packed_args.unpack<Tensor>();
  auto reduction = packed_args.unpack<int64_t>();
  auto self = packed_args.unpack<Tensor>();
  auto target = packed_args.unpack<Tensor>();
  return SoftMarginLossBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, grad_output, reduction, self, target);
#endif
}

variable_list SoftMarginLossBackwardBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto grad_output = grad_output_.unpack();
  auto self = self_.unpack();
  auto target = target_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  return SoftMarginLossBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, grad_output, reduction, self, target);
}

void SoftMarginLossBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(grad_output_, false);
    args.collect(reduction);
    args.collect(self_, false);
    args.collect(target_, false);
}
variable_list SoftMarginLossBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(grad_output_);
  saved.before(reduction);
  saved.before(self_);
  saved.before(target_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SoftMarginLossBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto grad_output = grad_output_.unpack();
  auto self = self_.unpack();
  auto target = target_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(grad_output);
  packed_args.pack(reduction);
  packed_args.pack(self);
  packed_args.pack(target);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(grad_output_);
  saved.after(reduction);
  saved.after(self_);
  saved.after(target_);
  return output_result;
#endif
}

static variable_list SoftshrinkBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, at::Scalar& lambd, Tensor& self)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (softshrink_backward(grad, self, lambd)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  if (needs_input_grad[/*self*/1]) {
    auto grad_result = any_grad_defined ? (zeros_like(grad)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SoftshrinkBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto lambd = packed_args.unpack<at::Scalar>();
  auto self = packed_args.unpack<Tensor>();
  return SoftshrinkBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, lambd, self);
#endif
}

variable_list SoftshrinkBackwardBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  return SoftshrinkBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, lambd, self);
}

void SoftshrinkBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(lambd);
    args.collect(self_, false);
}
variable_list SoftshrinkBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(lambd);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SoftshrinkBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(lambd);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(lambd);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list ThresholdBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& self, at::Scalar& threshold)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (threshold_backward(grad, self, threshold)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  if (needs_input_grad[/*self*/1]) {
    auto grad_result = any_grad_defined ? (zeros_like(grad)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ThresholdBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto self = packed_args.unpack<Tensor>();
  auto threshold = packed_args.unpack<at::Scalar>();
  return ThresholdBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, self, threshold);
#endif
}

variable_list ThresholdBackwardBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  return ThresholdBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, self, threshold);
}

void ThresholdBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
    args.collect(threshold);
}
variable_list ThresholdBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);
  saved.before(threshold);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ThresholdBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);
  packed_args.pack(threshold);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  saved.after(threshold);
  return output_result;
#endif
}

static variable_list UpsampleLinear1DBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, bool& align_corners, std::vector<c10::SymInt>& output_size, ::std::optional<double>& scales)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (upsample_linear1d_symint(grad, output_size, align_corners, scales)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list UpsampleLinear1DBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto align_corners = packed_args.unpack<bool>();
  auto output_size = packed_args.unpack<std::vector<c10::SymInt>>();
  auto scales = packed_args.unpack<::std::optional<double>>();
  return UpsampleLinear1DBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, align_corners, output_size, scales);
#endif
}

variable_list UpsampleLinear1DBackwardBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ grad_output_ix }),
  };
  return UpsampleLinear1DBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, align_corners, output_size, scales);
}

void UpsampleLinear1DBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(align_corners);
    args.collect(output_size);
    args.collect(scales);
}
variable_list UpsampleLinear1DBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(align_corners);
  saved.before(output_size);
  saved.before(scales);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), UpsampleLinear1DBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ grad_output_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(align_corners);
  packed_args.pack(output_size);
  packed_args.pack(scales);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(align_corners);
  saved.after(output_size);
  saved.after(scales);
  return output_result;
#endif
}

static variable_list UpsampleBilinear2DBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, bool& align_corners, std::vector<c10::SymInt>& output_size, ::std::optional<double>& scales_h, ::std::optional<double>& scales_w)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (upsample_bilinear2d_symint(grad, output_size, align_corners, scales_h, scales_w)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list UpsampleBilinear2DBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto align_corners = packed_args.unpack<bool>();
  auto output_size = packed_args.unpack<std::vector<c10::SymInt>>();
  auto scales_h = packed_args.unpack<::std::optional<double>>();
  auto scales_w = packed_args.unpack<::std::optional<double>>();
  return UpsampleBilinear2DBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, align_corners, output_size, scales_h, scales_w);
#endif
}

variable_list UpsampleBilinear2DBackwardBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ grad_output_ix }),
  };
  return UpsampleBilinear2DBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, align_corners, output_size, scales_h, scales_w);
}

void UpsampleBilinear2DBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(align_corners);
    args.collect(output_size);
    args.collect(scales_h);
    args.collect(scales_w);
}
variable_list UpsampleBilinear2DBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(align_corners);
  saved.before(output_size);
  saved.before(scales_h);
  saved.before(scales_w);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), UpsampleBilinear2DBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ grad_output_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(align_corners);
  packed_args.pack(output_size);
  packed_args.pack(scales_h);
  packed_args.pack(scales_w);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(align_corners);
  saved.after(output_size);
  saved.after(scales_h);
  saved.after(scales_w);
  return output_result;
#endif
}

static variable_list UpsampleBilinear2DAaBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, bool& align_corners, std::vector<c10::SymInt>& output_size, ::std::optional<double>& scales_h, ::std::optional<double>& scales_w)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (_upsample_bilinear2d_aa_symint(grad, output_size, align_corners, scales_h, scales_w)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list UpsampleBilinear2DAaBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto align_corners = packed_args.unpack<bool>();
  auto output_size = packed_args.unpack<std::vector<c10::SymInt>>();
  auto scales_h = packed_args.unpack<::std::optional<double>>();
  auto scales_w = packed_args.unpack<::std::optional<double>>();
  return UpsampleBilinear2DAaBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, align_corners, output_size, scales_h, scales_w);
#endif
}

variable_list UpsampleBilinear2DAaBackwardBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ grad_output_ix }),
  };
  return UpsampleBilinear2DAaBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, align_corners, output_size, scales_h, scales_w);
}

void UpsampleBilinear2DAaBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(align_corners);
    args.collect(output_size);
    args.collect(scales_h);
    args.collect(scales_w);
}
variable_list UpsampleBilinear2DAaBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(align_corners);
  saved.before(output_size);
  saved.before(scales_h);
  saved.before(scales_w);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), UpsampleBilinear2DAaBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ grad_output_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(align_corners);
  packed_args.pack(output_size);
  packed_args.pack(scales_h);
  packed_args.pack(scales_w);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(align_corners);
  saved.after(output_size);
  saved.after(scales_h);
  saved.after(scales_w);
  return output_result;
#endif
}

static variable_list UpsampleBicubic2DBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, bool& align_corners, std::vector<c10::SymInt>& output_size, ::std::optional<double>& scales_h, ::std::optional<double>& scales_w)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (upsample_bicubic2d_symint(grad, output_size, align_corners, scales_h, scales_w)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list UpsampleBicubic2DBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto align_corners = packed_args.unpack<bool>();
  auto output_size = packed_args.unpack<std::vector<c10::SymInt>>();
  auto scales_h = packed_args.unpack<::std::optional<double>>();
  auto scales_w = packed_args.unpack<::std::optional<double>>();
  return UpsampleBicubic2DBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, align_corners, output_size, scales_h, scales_w);
#endif
}

variable_list UpsampleBicubic2DBackwardBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ grad_output_ix }),
  };
  return UpsampleBicubic2DBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, align_corners, output_size, scales_h, scales_w);
}

void UpsampleBicubic2DBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(align_corners);
    args.collect(output_size);
    args.collect(scales_h);
    args.collect(scales_w);
}
variable_list UpsampleBicubic2DBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(align_corners);
  saved.before(output_size);
  saved.before(scales_h);
  saved.before(scales_w);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), UpsampleBicubic2DBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ grad_output_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(align_corners);
  packed_args.pack(output_size);
  packed_args.pack(scales_h);
  packed_args.pack(scales_w);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(align_corners);
  saved.after(output_size);
  saved.after(scales_h);
  saved.after(scales_w);
  return output_result;
#endif
}

static variable_list UpsampleBicubic2DAaBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, bool& align_corners, std::vector<c10::SymInt>& output_size, ::std::optional<double>& scales_h, ::std::optional<double>& scales_w)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (_upsample_bicubic2d_aa_symint(grad, output_size, align_corners, scales_h, scales_w)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list UpsampleBicubic2DAaBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto align_corners = packed_args.unpack<bool>();
  auto output_size = packed_args.unpack<std::vector<c10::SymInt>>();
  auto scales_h = packed_args.unpack<::std::optional<double>>();
  auto scales_w = packed_args.unpack<::std::optional<double>>();
  return UpsampleBicubic2DAaBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, align_corners, output_size, scales_h, scales_w);
#endif
}

variable_list UpsampleBicubic2DAaBackwardBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ grad_output_ix }),
  };
  return UpsampleBicubic2DAaBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, align_corners, output_size, scales_h, scales_w);
}

void UpsampleBicubic2DAaBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(align_corners);
    args.collect(output_size);
    args.collect(scales_h);
    args.collect(scales_w);
}
variable_list UpsampleBicubic2DAaBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(align_corners);
  saved.before(output_size);
  saved.before(scales_h);
  saved.before(scales_w);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), UpsampleBicubic2DAaBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ grad_output_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(align_corners);
  packed_args.pack(output_size);
  packed_args.pack(scales_h);
  packed_args.pack(scales_w);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(align_corners);
  saved.after(output_size);
  saved.after(scales_h);
  saved.after(scales_w);
  return output_result;
#endif
}

static variable_list UpsampleTrilinear3DBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, bool& align_corners, std::vector<c10::SymInt>& output_size, ::std::optional<double>& scales_d, ::std::optional<double>& scales_h, ::std::optional<double>& scales_w)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (upsample_trilinear3d_symint(grad, output_size, align_corners, scales_d, scales_h, scales_w)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list UpsampleTrilinear3DBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto align_corners = packed_args.unpack<bool>();
  auto output_size = packed_args.unpack<std::vector<c10::SymInt>>();
  auto scales_d = packed_args.unpack<::std::optional<double>>();
  auto scales_h = packed_args.unpack<::std::optional<double>>();
  auto scales_w = packed_args.unpack<::std::optional<double>>();
  return UpsampleTrilinear3DBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, align_corners, output_size, scales_d, scales_h, scales_w);
#endif
}

variable_list UpsampleTrilinear3DBackwardBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ grad_output_ix }),
  };
  return UpsampleTrilinear3DBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, align_corners, output_size, scales_d, scales_h, scales_w);
}

void UpsampleTrilinear3DBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(align_corners);
    args.collect(output_size);
    args.collect(scales_d);
    args.collect(scales_h);
    args.collect(scales_w);
}
variable_list UpsampleTrilinear3DBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(align_corners);
  saved.before(output_size);
  saved.before(scales_d);
  saved.before(scales_h);
  saved.before(scales_w);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), UpsampleTrilinear3DBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ grad_output_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(align_corners);
  packed_args.pack(output_size);
  packed_args.pack(scales_d);
  packed_args.pack(scales_h);
  packed_args.pack(scales_w);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(align_corners);
  saved.after(output_size);
  saved.after(scales_d);
  saved.after(scales_h);
  saved.after(scales_w);
  return output_result;
#endif
}

static variable_list UpsampleNearest1DBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<c10::SymInt>& output_size, ::std::optional<double>& scales)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (upsample_nearest1d_symint(grad, output_size, scales)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list UpsampleNearest1DBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto output_size = packed_args.unpack<std::vector<c10::SymInt>>();
  auto scales = packed_args.unpack<::std::optional<double>>();
  return UpsampleNearest1DBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, output_size, scales);
#endif
}

variable_list UpsampleNearest1DBackwardBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ grad_output_ix }),
  };
  return UpsampleNearest1DBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, output_size, scales);
}

void UpsampleNearest1DBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(output_size);
    args.collect(scales);
}
variable_list UpsampleNearest1DBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(output_size);
  saved.before(scales);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), UpsampleNearest1DBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ grad_output_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(output_size);
  packed_args.pack(scales);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(output_size);
  saved.after(scales);
  return output_result;
#endif
}

static variable_list UpsampleNearestExact1DBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<c10::SymInt>& output_size, ::std::optional<double>& scales)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (_upsample_nearest_exact1d_symint(grad, output_size, scales)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list UpsampleNearestExact1DBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto output_size = packed_args.unpack<std::vector<c10::SymInt>>();
  auto scales = packed_args.unpack<::std::optional<double>>();
  return UpsampleNearestExact1DBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, output_size, scales);
#endif
}

variable_list UpsampleNearestExact1DBackwardBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ grad_output_ix }),
  };
  return UpsampleNearestExact1DBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, output_size, scales);
}

void UpsampleNearestExact1DBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(output_size);
    args.collect(scales);
}
variable_list UpsampleNearestExact1DBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(output_size);
  saved.before(scales);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), UpsampleNearestExact1DBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ grad_output_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(output_size);
  packed_args.pack(scales);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(output_size);
  saved.after(scales);
  return output_result;
#endif
}

static variable_list UpsampleNearest2DBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<c10::SymInt>& output_size, ::std::optional<double>& scales_h, ::std::optional<double>& scales_w)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (upsample_nearest2d_symint(grad, output_size, scales_h, scales_w)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list UpsampleNearest2DBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto output_size = packed_args.unpack<std::vector<c10::SymInt>>();
  auto scales_h = packed_args.unpack<::std::optional<double>>();
  auto scales_w = packed_args.unpack<::std::optional<double>>();
  return UpsampleNearest2DBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, output_size, scales_h, scales_w);
#endif
}

variable_list UpsampleNearest2DBackwardBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ grad_output_ix }),
  };
  return UpsampleNearest2DBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, output_size, scales_h, scales_w);
}

void UpsampleNearest2DBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(output_size);
    args.collect(scales_h);
    args.collect(scales_w);
}
variable_list UpsampleNearest2DBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(output_size);
  saved.before(scales_h);
  saved.before(scales_w);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), UpsampleNearest2DBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ grad_output_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(output_size);
  packed_args.pack(scales_h);
  packed_args.pack(scales_w);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(output_size);
  saved.after(scales_h);
  saved.after(scales_w);
  return output_result;
#endif
}

static variable_list UpsampleNearestExact2DBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<c10::SymInt>& output_size, ::std::optional<double>& scales_h, ::std::optional<double>& scales_w)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (_upsample_nearest_exact2d_symint(grad, output_size, scales_h, scales_w)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list UpsampleNearestExact2DBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto output_size = packed_args.unpack<std::vector<c10::SymInt>>();
  auto scales_h = packed_args.unpack<::std::optional<double>>();
  auto scales_w = packed_args.unpack<::std::optional<double>>();
  return UpsampleNearestExact2DBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, output_size, scales_h, scales_w);
#endif
}

variable_list UpsampleNearestExact2DBackwardBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ grad_output_ix }),
  };
  return UpsampleNearestExact2DBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, output_size, scales_h, scales_w);
}

void UpsampleNearestExact2DBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(output_size);
    args.collect(scales_h);
    args.collect(scales_w);
}
variable_list UpsampleNearestExact2DBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(output_size);
  saved.before(scales_h);
  saved.before(scales_w);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), UpsampleNearestExact2DBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ grad_output_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(output_size);
  packed_args.pack(scales_h);
  packed_args.pack(scales_w);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(output_size);
  saved.after(scales_h);
  saved.after(scales_w);
  return output_result;
#endif
}

static variable_list UpsampleNearest3DBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<c10::SymInt>& output_size, ::std::optional<double>& scales_d, ::std::optional<double>& scales_h, ::std::optional<double>& scales_w)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (upsample_nearest3d_symint(grad, output_size, scales_d, scales_h, scales_w)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list UpsampleNearest3DBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto output_size = packed_args.unpack<std::vector<c10::SymInt>>();
  auto scales_d = packed_args.unpack<::std::optional<double>>();
  auto scales_h = packed_args.unpack<::std::optional<double>>();
  auto scales_w = packed_args.unpack<::std::optional<double>>();
  return UpsampleNearest3DBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, output_size, scales_d, scales_h, scales_w);
#endif
}

variable_list UpsampleNearest3DBackwardBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ grad_output_ix }),
  };
  return UpsampleNearest3DBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, output_size, scales_d, scales_h, scales_w);
}

void UpsampleNearest3DBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(output_size);
    args.collect(scales_d);
    args.collect(scales_h);
    args.collect(scales_w);
}
variable_list UpsampleNearest3DBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(output_size);
  saved.before(scales_d);
  saved.before(scales_h);
  saved.before(scales_w);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), UpsampleNearest3DBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ grad_output_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(output_size);
  packed_args.pack(scales_d);
  packed_args.pack(scales_h);
  packed_args.pack(scales_w);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(output_size);
  saved.after(scales_d);
  saved.after(scales_h);
  saved.after(scales_w);
  return output_result;
#endif
}

static variable_list UpsampleNearestExact3DBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<c10::SymInt>& output_size, ::std::optional<double>& scales_d, ::std::optional<double>& scales_h, ::std::optional<double>& scales_w)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (_upsample_nearest_exact3d_symint(grad, output_size, scales_d, scales_h, scales_w)) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list UpsampleNearestExact3DBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto output_size = packed_args.unpack<std::vector<c10::SymInt>>();
  auto scales_d = packed_args.unpack<::std::optional<double>>();
  auto scales_h = packed_args.unpack<::std::optional<double>>();
  auto scales_w = packed_args.unpack<::std::optional<double>>();
  return UpsampleNearestExact3DBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, output_size, scales_d, scales_h, scales_w);
#endif
}

variable_list UpsampleNearestExact3DBackwardBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ grad_output_ix }),
  };
  return UpsampleNearestExact3DBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, output_size, scales_d, scales_h, scales_w);
}

void UpsampleNearestExact3DBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(output_size);
    args.collect(scales_d);
    args.collect(scales_h);
    args.collect(scales_w);
}
variable_list UpsampleNearestExact3DBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(output_size);
  saved.before(scales_d);
  saved.before(scales_h);
  saved.before(scales_w);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), UpsampleNearestExact3DBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ grad_output_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(output_size);
  packed_args.pack(scales_d);
  packed_args.pack(scales_h);
  packed_args.pack(scales_w);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(output_size);
  saved.after(scales_d);
  saved.after(scales_h);
  saved.after(scales_w);
  return output_result;
#endif
}

static variable_list SigmoidBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& grad_output, Tensor& output)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto output_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (sigmoid_backward(grad, output.conj())) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  if (needs_input_grad[/*output*/1]) {
    auto grad_result = any_grad_defined ? (grad.conj() * grad_output * (-2 * output.conj() + 1)) : Tensor();
    copy_range(grad_inputs, output_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SigmoidBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto grad_output = packed_args.unpack<Tensor>();
  auto output = packed_args.unpack<Tensor>();
  return SigmoidBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, grad_output, output);
#endif
}

variable_list SigmoidBackwardBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto grad_output = grad_output_.unpack();
  auto output = output_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto output_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ output_ix }),
  };
  return SigmoidBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, grad_output, output);
}

void SigmoidBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(grad_output_, false);
    args.collect(output_, false);
}
variable_list SigmoidBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(grad_output_);
  saved.before(output_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SigmoidBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto grad_output = grad_output_.unpack();
  auto output = output_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto output_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ output_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(grad_output);
  packed_args.pack(output);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(grad_output_);
  saved.after(output_);
  return output_result;
#endif
}

static variable_list TanhBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& grad_output, Tensor& output)
{
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto output_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*grad_output*/0]) {
    auto grad_result = any_grad_defined ? (tanh_backward(grad, output.conj())) : Tensor();
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  if (needs_input_grad[/*output*/1]) {
    auto grad_result = any_grad_defined ? (grad.conj() * (-2 * output.conj() * grad_output)) : Tensor();
    copy_range(grad_inputs, output_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list TanhBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto grad_output = packed_args.unpack<Tensor>();
  auto output = packed_args.unpack<Tensor>();
  return TanhBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, grad_output, output);
#endif
}

variable_list TanhBackwardBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto grad_output = grad_output_.unpack();
  auto output = output_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto output_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ output_ix }),
  };
  return TanhBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, grad_output, output);
}

void TanhBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(grad_output_, false);
    args.collect(output_, false);
}
variable_list TanhBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(grad_output_);
  saved.before(output_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), TanhBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto grad_output = grad_output_.unpack();
  auto output = output_.unpack();
  IndexRangeGenerator gen;
  auto grad_output_ix = gen.range(1);
  auto output_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ output_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(grad_output);
  packed_args.pack(output);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(grad_output_);
  saved.after(output_);
  return output_result;
#endif
}

static variable_list CudnnCtcLossBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, bool& zero_infinity, Tensor& result0, Tensor& result1)
{
  IndexRangeGenerator gen;
  auto log_probs_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*log_probs*/0]) {
    auto grad_result = any_grad_defined ? (_cudnn_ctc_loss_backward(grad, result0, result1, zero_infinity)) : Tensor();
    copy_range(grad_inputs, log_probs_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list CudnnCtcLossBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto zero_infinity = packed_args.unpack<bool>();
  auto result0 = packed_args.unpack<Tensor>();
  auto result1 = packed_args.unpack<Tensor>();
  return CudnnCtcLossBackward0_apply_functional(variable_list(grads), needs_input_grad, zero_infinity, result0, result1);
#endif
}

variable_list CudnnCtcLossBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto result0 = result0_.unpack(shared_from_this());
  auto result1 = result1_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto log_probs_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ log_probs_ix }),
  };
  return CudnnCtcLossBackward0_apply_functional(std::move(grads), needs_input_grad, zero_infinity, result0, result1);
}

void CudnnCtcLossBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(zero_infinity);
    args.collect(result0_, true);
    args.collect(result1_, true);
}
variable_list CudnnCtcLossBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(zero_infinity);
  saved.before(result0_);
  saved.before(result1_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), CudnnCtcLossBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto result0 = result0_.unpack(shared_from_this());
  auto result1 = result1_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto log_probs_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ log_probs_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(zero_infinity);
  packed_args.pack(result0);
  packed_args.pack(result1);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(zero_infinity);
  saved.after(result0_);
  saved.after(result1_);
  return output_result;
#endif
}

static variable_list CudnnCtcLossBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, bool& zero_infinity, Tensor& result0, Tensor& result1)
{
  IndexRangeGenerator gen;
  auto log_probs_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*log_probs*/0]) {
    auto grad_result = any_grad_defined ? (_cudnn_ctc_loss_backward(grad, result0, result1, zero_infinity)) : Tensor();
    copy_range(grad_inputs, log_probs_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list CudnnCtcLossBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto zero_infinity = packed_args.unpack<bool>();
  auto result0 = packed_args.unpack<Tensor>();
  auto result1 = packed_args.unpack<Tensor>();
  return CudnnCtcLossBackward1_apply_functional(variable_list(grads), needs_input_grad, zero_infinity, result0, result1);
#endif
}

variable_list CudnnCtcLossBackward1::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto result0 = result0_.unpack(shared_from_this());
  auto result1 = result1_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto log_probs_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ log_probs_ix }),
  };
  return CudnnCtcLossBackward1_apply_functional(std::move(grads), needs_input_grad, zero_infinity, result0, result1);
}

void CudnnCtcLossBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(zero_infinity);
    args.collect(result0_, true);
    args.collect(result1_, true);
}
variable_list CudnnCtcLossBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(zero_infinity);
  saved.before(result0_);
  saved.before(result1_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), CudnnCtcLossBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto result0 = result0_.unpack(shared_from_this());
  auto result1 = result1_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto log_probs_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ log_probs_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(zero_infinity);
  packed_args.pack(result0);
  packed_args.pack(result1);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(zero_infinity);
  saved.after(result0_);
  saved.after(result1_);
  return output_result;
#endif
}

static variable_list CudnnConvolutionTransposeBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, std::vector<c10::SymInt>& dilation, c10::SymInt& groups, std::vector<c10::SymInt>& output_padding, std::vector<c10::SymInt>& padding, Tensor& self, std::vector<c10::SymInt>& stride, Tensor& weight)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1]) {
      auto grad_input_mask = std::array<bool, 2>{
        needs_input_grad[0],
        needs_input_grad[1],
      };
    auto grad_result = _cudnn_convolution_backward(self, grad, weight, padding, output_padding, stride, dilation, true, groups, {grad_input_mask[0], grad_input_mask[1]});
      if (needs_input_grad[/*self*/0]) {
        copy_range(grad_inputs, self_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*weight*/1]) {
        copy_range(grad_inputs, weight_ix, std::get<1>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list CudnnConvolutionTransposeBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto dilation = packed_args.unpack<std::vector<c10::SymInt>>();
  auto groups = packed_args.unpack<c10::SymInt>();
  auto output_padding = packed_args.unpack<std::vector<c10::SymInt>>();
  auto padding = packed_args.unpack<std::vector<c10::SymInt>>();
  auto self = packed_args.unpack<Tensor>();
  auto stride = packed_args.unpack<std::vector<c10::SymInt>>();
  auto weight = packed_args.unpack<Tensor>();
  return CudnnConvolutionTransposeBackward0_apply_functional(variable_list(grads), needs_input_grad, dilation, groups, output_padding, padding, self, stride, weight);
#endif
}

variable_list CudnnConvolutionTransposeBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ weight_ix }),
  };
  return CudnnConvolutionTransposeBackward0_apply_functional(std::move(grads), needs_input_grad, dilation, groups, output_padding, padding, self, stride, weight);
}

void CudnnConvolutionTransposeBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dilation);
    args.collect(groups);
    args.collect(output_padding);
    args.collect(padding);
    args.collect(self_, false);
    args.collect(stride);
    args.collect(weight_, false);
}
variable_list CudnnConvolutionTransposeBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dilation);
  saved.before(groups);
  saved.before(output_padding);
  saved.before(padding);
  saved.before(self_);
  saved.before(stride);
  saved.before(weight_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), CudnnConvolutionTransposeBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ weight_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dilation);
  packed_args.pack(groups);
  packed_args.pack(output_padding);
  packed_args.pack(padding);
  packed_args.pack(self);
  packed_args.pack(stride);
  packed_args.pack(weight);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dilation);
  saved.after(groups);
  saved.after(output_padding);
  saved.after(padding);
  saved.after(self_);
  saved.after(stride);
  saved.after(weight_);
  return output_result;
#endif
}

static variable_list MpsConvolutionTransposeBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, std::vector<c10::SymInt>& dilation, c10::SymInt& groups, std::vector<c10::SymInt>& output_padding, std::vector<c10::SymInt>& padding, Tensor& self, std::vector<c10::SymInt>& stride, Tensor& weight)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1]) {
      auto grad_input_mask = std::array<bool, 2>{
        needs_input_grad[0],
        needs_input_grad[1],
      };
    auto grad_result = grad.defined() ? mps_convolution_transpose_backward_symint(self, grad, weight, padding, output_padding, stride, dilation, groups, grad_input_mask) : std::tuple<Tensor, Tensor>();
      if (needs_input_grad[/*self*/0]) {
        copy_range(grad_inputs, self_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*weight*/1]) {
        copy_range(grad_inputs, weight_ix, std::get<1>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list MpsConvolutionTransposeBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto dilation = packed_args.unpack<std::vector<c10::SymInt>>();
  auto groups = packed_args.unpack<c10::SymInt>();
  auto output_padding = packed_args.unpack<std::vector<c10::SymInt>>();
  auto padding = packed_args.unpack<std::vector<c10::SymInt>>();
  auto self = packed_args.unpack<Tensor>();
  auto stride = packed_args.unpack<std::vector<c10::SymInt>>();
  auto weight = packed_args.unpack<Tensor>();
  return MpsConvolutionTransposeBackward0_apply_functional(variable_list(grads), needs_input_grad, dilation, groups, output_padding, padding, self, stride, weight);
#endif
}

variable_list MpsConvolutionTransposeBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ weight_ix }),
  };
  return MpsConvolutionTransposeBackward0_apply_functional(std::move(grads), needs_input_grad, dilation, groups, output_padding, padding, self, stride, weight);
}

void MpsConvolutionTransposeBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dilation);
    args.collect(groups);
    args.collect(output_padding);
    args.collect(padding);
    args.collect(self_, false);
    args.collect(stride);
    args.collect(weight_, false);
}
variable_list MpsConvolutionTransposeBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dilation);
  saved.before(groups);
  saved.before(output_padding);
  saved.before(padding);
  saved.before(self_);
  saved.before(stride);
  saved.before(weight_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MpsConvolutionTransposeBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ weight_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dilation);
  packed_args.pack(groups);
  packed_args.pack(output_padding);
  packed_args.pack(padding);
  packed_args.pack(self);
  packed_args.pack(stride);
  packed_args.pack(weight);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dilation);
  saved.after(groups);
  saved.after(output_padding);
  saved.after(padding);
  saved.after(self_);
  saved.after(stride);
  saved.after(weight_);
  return output_result;
#endif
}

static variable_list CudnnConvolutionBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, std::vector<c10::SymInt>& dilation, c10::SymInt& groups, std::vector<c10::SymInt>& padding, Tensor& self, std::vector<c10::SymInt>& stride, Tensor& weight)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1]) {
      auto grad_input_mask = std::array<bool, 2>{
        needs_input_grad[0],
        needs_input_grad[1],
      };
    auto grad_result = _cudnn_convolution_backward(self, grad, weight, padding, std::vector<c10::SymInt>(padding.size(), 0), stride, dilation, false, groups, {grad_input_mask[0], grad_input_mask[1]});
      if (needs_input_grad[/*self*/0]) {
        copy_range(grad_inputs, self_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*weight*/1]) {
        copy_range(grad_inputs, weight_ix, std::get<1>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list CudnnConvolutionBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto dilation = packed_args.unpack<std::vector<c10::SymInt>>();
  auto groups = packed_args.unpack<c10::SymInt>();
  auto padding = packed_args.unpack<std::vector<c10::SymInt>>();
  auto self = packed_args.unpack<Tensor>();
  auto stride = packed_args.unpack<std::vector<c10::SymInt>>();
  auto weight = packed_args.unpack<Tensor>();
  return CudnnConvolutionBackward0_apply_functional(variable_list(grads), needs_input_grad, dilation, groups, padding, self, stride, weight);
#endif
}

variable_list CudnnConvolutionBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ weight_ix }),
  };
  return CudnnConvolutionBackward0_apply_functional(std::move(grads), needs_input_grad, dilation, groups, padding, self, stride, weight);
}

void CudnnConvolutionBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dilation);
    args.collect(groups);
    args.collect(padding);
    args.collect(self_, false);
    args.collect(stride);
    args.collect(weight_, false);
}
variable_list CudnnConvolutionBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dilation);
  saved.before(groups);
  saved.before(padding);
  saved.before(self_);
  saved.before(stride);
  saved.before(weight_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), CudnnConvolutionBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ weight_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dilation);
  packed_args.pack(groups);
  packed_args.pack(padding);
  packed_args.pack(self);
  packed_args.pack(stride);
  packed_args.pack(weight);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dilation);
  saved.after(groups);
  saved.after(padding);
  saved.after(self_);
  saved.after(stride);
  saved.after(weight_);
  return output_result;
#endif
}

static variable_list CudnnGridSamplerBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, Tensor& grid, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto grid_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1]) {
  
    auto grad_result = grad.defined() ? cudnn_grid_sampler_backward(self, grid, grad) : std::tuple<Tensor, Tensor>();
      if (needs_input_grad[/*self*/0]) {
        copy_range(grad_inputs, self_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*grid*/1]) {
        copy_range(grad_inputs, grid_ix, std::get<1>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list CudnnGridSamplerBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto grid = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<Tensor>();
  return CudnnGridSamplerBackward0_apply_functional(variable_list(grads), needs_input_grad, grid, self);
#endif
}

variable_list CudnnGridSamplerBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto grid = grid_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto grid_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ grid_ix }),
  };
  return CudnnGridSamplerBackward0_apply_functional(std::move(grads), needs_input_grad, grid, self);
}

void CudnnGridSamplerBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(grid_, false);
    args.collect(self_, false);
}
variable_list CudnnGridSamplerBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(grid_);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), CudnnGridSamplerBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto grid = grid_.unpack();
  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto grid_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ grid_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(grid);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(grid_);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list CudnnAffineGridGeneratorBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& C, int64_t& H, int64_t& N, int64_t& W)
{
  IndexRangeGenerator gen;
  auto theta_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*theta*/0]) {
    auto grad_result = any_grad_defined ? (cudnn_affine_grid_generator_backward(grad, N, C, H, W)) : Tensor();
    copy_range(grad_inputs, theta_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list CudnnAffineGridGeneratorBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto C = packed_args.unpack<int64_t>();
  auto H = packed_args.unpack<int64_t>();
  auto N = packed_args.unpack<int64_t>();
  auto W = packed_args.unpack<int64_t>();
  return CudnnAffineGridGeneratorBackward0_apply_functional(variable_list(grads), needs_input_grad, C, H, N, W);
#endif
}

variable_list CudnnAffineGridGeneratorBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto theta_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ theta_ix }),
  };
  return CudnnAffineGridGeneratorBackward0_apply_functional(std::move(grads), needs_input_grad, C, H, N, W);
}

void CudnnAffineGridGeneratorBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(C);
    args.collect(H);
    args.collect(N);
    args.collect(W);
}
variable_list CudnnAffineGridGeneratorBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(C);
  saved.before(H);
  saved.before(N);
  saved.before(W);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), CudnnAffineGridGeneratorBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto theta_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ theta_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(C);
  packed_args.pack(H);
  packed_args.pack(N);
  packed_args.pack(W);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(C);
  saved.after(H);
  saved.after(N);
  saved.after(W);
  return output_result;
#endif
}

static variable_list CudnnBatchNormBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, double& epsilon, Tensor& input, Tensor& running_mean, Tensor& running_var, bool& training, Tensor& weight, Tensor& result1, Tensor& result2, Tensor& result3, bool retain_variables)
{
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1] || needs_input_grad[2]) {
      auto grad_input_mask = std::array<bool, 3>{
        needs_input_grad[0],
        needs_input_grad[1],
        needs_input_grad[2],
      };
    auto grad_result = grad.defined() ? (training ? cudnn_batch_norm_backward(input, grad.contiguous(input.suggest_memory_format()), weight, running_mean, running_var, result1, result2, epsilon, retain_variables ? result3.clone() : result3) : native_batch_norm_backward(grad, input, weight, running_mean, running_var, result1, result2, training, epsilon, grad_input_mask)) : std::tuple<Tensor, Tensor, Tensor>();
      if (needs_input_grad[/*input*/0]) {
        copy_range(grad_inputs, input_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*weight*/1]) {
        copy_range(grad_inputs, weight_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*bias*/2]) {
        copy_range(grad_inputs, bias_ix, std::get<2>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list CudnnBatchNormBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto epsilon = packed_args.unpack<double>();
  auto input = packed_args.unpack<Tensor>();
  auto running_mean = packed_args.unpack<Tensor>();
  auto running_var = packed_args.unpack<Tensor>();
  auto training = packed_args.unpack<bool>();
  auto weight = packed_args.unpack<Tensor>();
  auto result1 = packed_args.unpack<Tensor>();
  auto result2 = packed_args.unpack<Tensor>();
  auto result3 = packed_args.unpack<Tensor>();
  auto retain_variables = packed_args.unpack<bool>();
  return CudnnBatchNormBackward0_apply_functional(variable_list(grads), needs_input_grad, epsilon, input, running_mean, running_var, training, weight, result1, result2, result3, retain_variables);
#endif
}

variable_list CudnnBatchNormBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto input = input_.unpack();
  auto running_mean = running_mean_.unpack();
  auto running_var = running_var_.unpack();
  auto weight = weight_.unpack();
  auto result1 = result1_.unpack(shared_from_this());
  auto result2 = result2_.unpack(shared_from_this());
  auto result3 = result3_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  return CudnnBatchNormBackward0_apply_functional(std::move(grads), needs_input_grad, epsilon, input, running_mean, running_var, training, weight, result1, result2, result3, retain_variables);
}

void CudnnBatchNormBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(epsilon);
    args.collect(input_, false);
    args.collect(running_mean_, false);
    args.collect(running_var_, false);
    args.collect(training);
    args.collect(weight_, false);
    args.collect(result1_, true);
    args.collect(result2_, true);
    args.collect(result3_, true);
}
variable_list CudnnBatchNormBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(epsilon);
  saved.before(input_);
  saved.before(running_mean_);
  saved.before(running_var_);
  saved.before(training);
  saved.before(weight_);
  saved.before(result1_);
  saved.before(result2_);
  saved.before(result3_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<double>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), CudnnBatchNormBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto input = input_.unpack();
  auto running_mean = running_mean_.unpack();
  auto running_var = running_var_.unpack();
  auto weight = weight_.unpack();
  auto result1 = result1_.unpack(shared_from_this());
  auto result2 = result2_.unpack(shared_from_this());
  auto result3 = result3_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(epsilon);
  packed_args.pack(input);
  packed_args.pack(running_mean);
  packed_args.pack(running_var);
  packed_args.pack(training);
  packed_args.pack(weight);
  packed_args.pack(result1);
  packed_args.pack(result2);
  packed_args.pack(result3);
  packed_args.pack(retain_variables);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(epsilon);
  saved.after(input_);
  saved.after(running_mean_);
  saved.after(running_var_);
  saved.after(training);
  saved.after(weight_);
  saved.after(result1_);
  saved.after(result2_);
  saved.after(result3_);
  return output_result;
#endif
}

static variable_list CudnnBatchNormBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,6> needs_input_grad, double& epsilon, Tensor& grad_output, Tensor& input, Tensor& reserveSpace, Tensor& running_mean, Tensor& running_var, Tensor& save_mean, Tensor& save_var, Tensor& weight)
{
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto grad_output_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto save_mean_ix = gen.range(1);
  auto save_var_ix = gen.range(1);
  auto reserveSpace_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[0] || needs_input_grad[2] || needs_input_grad[1]) {
      auto grad_input_mask = std::array<bool, 3>{
        needs_input_grad[0],
        needs_input_grad[2],
        needs_input_grad[1],
      };
    auto grad_result = batchnorm_double_backward(input, weight, grads[0], grads[1], grads[2], grad_output, running_mean, running_var, true, epsilon, save_mean, save_var, grad_input_mask);
      if (needs_input_grad[/*input*/0]) {
        copy_range(grad_inputs, input_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*weight*/2]) {
        copy_range(grad_inputs, weight_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*grad_output*/1]) {
        copy_range(grad_inputs, grad_output_ix, std::get<2>(grad_result));
      }
  }
  if (needs_input_grad[/*reserveSpace*/5]) {
    auto grad_result = not_implemented("cudnn_batch_norm_backward reserveSpace");
    copy_range(grad_inputs, reserveSpace_ix, grad_result);
  }
  if (needs_input_grad[/*save_mean*/3]) {
    auto grad_result = not_implemented("cudnn_batch_norm_backward save_mean");
    copy_range(grad_inputs, save_mean_ix, grad_result);
  }
  if (needs_input_grad[/*save_var*/4]) {
    auto grad_result = not_implemented("cudnn_batch_norm_backward save_var");
    copy_range(grad_inputs, save_var_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list CudnnBatchNormBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 6>>();
  auto epsilon = packed_args.unpack<double>();
  auto grad_output = packed_args.unpack<Tensor>();
  auto input = packed_args.unpack<Tensor>();
  auto reserveSpace = packed_args.unpack<Tensor>();
  auto running_mean = packed_args.unpack<Tensor>();
  auto running_var = packed_args.unpack<Tensor>();
  auto save_mean = packed_args.unpack<Tensor>();
  auto save_var = packed_args.unpack<Tensor>();
  auto weight = packed_args.unpack<Tensor>();
  return CudnnBatchNormBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, epsilon, grad_output, input, reserveSpace, running_mean, running_var, save_mean, save_var, weight);
#endif
}

variable_list CudnnBatchNormBackwardBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto grad_output = grad_output_.unpack();
  auto input = input_.unpack();
  auto reserveSpace = reserveSpace_.unpack();
  auto running_mean = running_mean_.unpack();
  auto running_var = running_var_.unpack();
  auto save_mean = save_mean_.unpack();
  auto save_var = save_var_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto grad_output_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto save_mean_ix = gen.range(1);
  auto save_var_ix = gen.range(1);
  auto reserveSpace_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 6>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ save_mean_ix }),
    task_should_compute_output({ save_var_ix }),
    task_should_compute_output({ reserveSpace_ix }),
  };
  return CudnnBatchNormBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, epsilon, grad_output, input, reserveSpace, running_mean, running_var, save_mean, save_var, weight);
}

void CudnnBatchNormBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(epsilon);
    args.collect(grad_output_, false);
    args.collect(input_, false);
    args.collect(reserveSpace_, false);
    args.collect(running_mean_, false);
    args.collect(running_var_, false);
    args.collect(save_mean_, false);
    args.collect(save_var_, false);
    args.collect(weight_, false);
}
variable_list CudnnBatchNormBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(epsilon);
  saved.before(grad_output_);
  saved.before(input_);
  saved.before(reserveSpace_);
  saved.before(running_mean_);
  saved.before(running_var_);
  saved.before(save_mean_);
  saved.before(save_var_);
  saved.before(weight_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 6>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<double>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), CudnnBatchNormBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto grad_output = grad_output_.unpack();
  auto input = input_.unpack();
  auto reserveSpace = reserveSpace_.unpack();
  auto running_mean = running_mean_.unpack();
  auto running_var = running_var_.unpack();
  auto save_mean = save_mean_.unpack();
  auto save_var = save_var_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto grad_output_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto save_mean_ix = gen.range(1);
  auto save_var_ix = gen.range(1);
  auto reserveSpace_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 6>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ save_mean_ix }),
    task_should_compute_output({ save_var_ix }),
    task_should_compute_output({ reserveSpace_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(epsilon);
  packed_args.pack(grad_output);
  packed_args.pack(input);
  packed_args.pack(reserveSpace);
  packed_args.pack(running_mean);
  packed_args.pack(running_var);
  packed_args.pack(save_mean);
  packed_args.pack(save_var);
  packed_args.pack(weight);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(epsilon);
  saved.after(grad_output_);
  saved.after(input_);
  saved.after(reserveSpace_);
  saved.after(running_mean_);
  saved.after(running_var_);
  saved.after(save_mean_);
  saved.after(save_var_);
  saved.after(weight_);
  return output_result;
#endif
}

static variable_list NnpackSpatialConvolutionBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, c10::OptionalArray<c10::SymInt>& bias_sym_sizes_opt, Tensor& input, std::vector<c10::SymInt>& padding, std::vector<c10::SymInt>& stride, Tensor& weight)
{
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1] || needs_input_grad[2]) {
      auto grad_input_mask = std::array<bool, 3>{
        needs_input_grad[0],
        needs_input_grad[1],
        needs_input_grad[2],
      };
    auto grad_result = grad.defined() ? convolution_backward_symint(grad, input, weight, bias_sym_sizes_opt, stride, padding, std::vector<c10::SymInt>(padding.size(), 1), false, std::vector<c10::SymInt>(padding.size(), 0), 1, grad_input_mask) : std::tuple<Tensor, Tensor, Tensor>();
      if (needs_input_grad[/*input*/0]) {
        copy_range(grad_inputs, input_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*weight*/1]) {
        copy_range(grad_inputs, weight_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*bias*/2]) {
        copy_range(grad_inputs, bias_ix, std::get<2>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list NnpackSpatialConvolutionBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto bias_sym_sizes_opt = packed_args.unpack<c10::OptionalArray<c10::SymInt>>();
  auto input = packed_args.unpack<Tensor>();
  auto padding = packed_args.unpack<std::vector<c10::SymInt>>();
  auto stride = packed_args.unpack<std::vector<c10::SymInt>>();
  auto weight = packed_args.unpack<Tensor>();
  return NnpackSpatialConvolutionBackward0_apply_functional(variable_list(grads), needs_input_grad, bias_sym_sizes_opt, input, padding, stride, weight);
#endif
}

variable_list NnpackSpatialConvolutionBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto input = input_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  return NnpackSpatialConvolutionBackward0_apply_functional(std::move(grads), needs_input_grad, bias_sym_sizes_opt, input, padding, stride, weight);
}

void NnpackSpatialConvolutionBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(bias_sym_sizes_opt);
    args.collect(input_, false);
    args.collect(padding);
    args.collect(stride);
    args.collect(weight_, false);
}
variable_list NnpackSpatialConvolutionBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(bias_sym_sizes_opt);
  saved.before(input_);
  saved.before(padding);
  saved.before(stride);
  saved.before(weight_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::OptionalArray<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), NnpackSpatialConvolutionBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto input = input_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(bias_sym_sizes_opt);
  packed_args.pack(input);
  packed_args.pack(padding);
  packed_args.pack(stride);
  packed_args.pack(weight);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(bias_sym_sizes_opt);
  saved.after(input_);
  saved.after(padding);
  saved.after(stride);
  saved.after(weight_);
  return output_result;
#endif
}

static variable_list LstmMpsBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, size_t hx_size_, size_t params_size_, bool& batch_first, bool& bidirectional, double& dropout, bool& has_biases, std::vector<Tensor>& hx, Tensor& input, int64_t& num_layers, std::vector<Tensor>& params, bool& train, Tensor& result3, Tensor& result4, Tensor& result5)
{
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto hx_ix = gen.range(hx_size_);
  auto params_ix = gen.range(params_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[0] || needs_input_grad[1] || needs_input_grad[2]) {
  
    auto grad_result = lstm_mps_backward(grads[0], grads[1], grads[2], result3, result4, input, result5, hx, params, has_biases, num_layers, dropout, train, bidirectional, batch_first);
      if (needs_input_grad[/*input*/0]) {
        copy_range(grad_inputs, input_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*hx*/1]) {
        copy_range(grad_inputs, hx_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*params*/2]) {
        copy_range(grad_inputs, params_ix, std::get<2>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list LstmMpsBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto hx_size_ = packed_args.unpack<size_t>();
  auto params_size_ = packed_args.unpack<size_t>();
  auto batch_first = packed_args.unpack<bool>();
  auto bidirectional = packed_args.unpack<bool>();
  auto dropout = packed_args.unpack<double>();
  auto has_biases = packed_args.unpack<bool>();
  auto hx = packed_args.unpack<std::vector<Tensor>>();
  auto input = packed_args.unpack<Tensor>();
  auto num_layers = packed_args.unpack<int64_t>();
  auto params = packed_args.unpack<std::vector<Tensor>>();
  auto train = packed_args.unpack<bool>();
  auto result3 = packed_args.unpack<Tensor>();
  auto result4 = packed_args.unpack<Tensor>();
  auto result5 = packed_args.unpack<Tensor>();
  return LstmMpsBackward0_apply_functional(variable_list(grads), needs_input_grad, hx_size_, params_size_, batch_first, bidirectional, dropout, has_biases, hx, input, num_layers, params, train, result3, result4, result5);
#endif
}

variable_list LstmMpsBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!hx_released_, ERR_BACKWARD_TWICE);
  TORCH_CHECK(!params_released_, ERR_BACKWARD_TWICE);
  auto hx = unpack_list(hx_, nullptr);
  auto input = input_.unpack();
  auto params = unpack_list(params_, nullptr);
  auto result3 = result3_.unpack(shared_from_this());
  auto result4 = result4_.unpack(shared_from_this());
  auto result5 = result5_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto hx_ix = gen.range(hx_size_);
  auto params_ix = gen.range(params_size_);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ hx_ix }),
    task_should_compute_output({ params_ix }),
  };
  return LstmMpsBackward0_apply_functional(std::move(grads), needs_input_grad, hx_size_, params_size_, batch_first, bidirectional, dropout, has_biases, hx, input, num_layers, params, train, result3, result4, result5);
}

void LstmMpsBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(batch_first);
    args.collect(bidirectional);
    args.collect(dropout);
    args.collect(has_biases);
    args.collect(hx_, false);
    args.collect(input_, false);
    args.collect(num_layers);
    args.collect(params_, false);
    args.collect(train);
    args.collect(result3_, true);
    args.collect(result4_, true);
    args.collect(result5_, true);
}
variable_list LstmMpsBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(batch_first);
  saved.before(bidirectional);
  saved.before(dropout);
  saved.before(has_biases);
  saved.before(hx_);
  saved.before(input_);
  saved.before(num_layers);
  saved.before(params_);
  saved.before(train);
  saved.before(result3_);
  saved.before(result4_);
  saved.before(result5_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<double>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), LstmMpsBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!hx_released_, ERR_BACKWARD_TWICE);
  TORCH_CHECK(!params_released_, ERR_BACKWARD_TWICE);
  auto hx = unpack_list(hx_, nullptr);
  auto input = input_.unpack();
  auto params = unpack_list(params_, nullptr);
  auto result3 = result3_.unpack(shared_from_this());
  auto result4 = result4_.unpack(shared_from_this());
  auto result5 = result5_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto hx_ix = gen.range(hx_size_);
  auto params_ix = gen.range(params_size_);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ hx_ix }),
    task_should_compute_output({ params_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(hx_size_);
  packed_args.pack(params_size_);
  packed_args.pack(batch_first);
  packed_args.pack(bidirectional);
  packed_args.pack(dropout);
  packed_args.pack(has_biases);
  packed_args.pack(hx);
  packed_args.pack(input);
  packed_args.pack(num_layers);
  packed_args.pack(params);
  packed_args.pack(train);
  packed_args.pack(result3);
  packed_args.pack(result4);
  packed_args.pack(result5);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(batch_first);
  saved.after(bidirectional);
  saved.after(dropout);
  saved.after(has_biases);
  saved.after(hx_);
  saved.after(input_);
  saved.after(num_layers);
  saved.after(params_);
  saved.after(train);
  saved.after(result3_);
  saved.after(result4_);
  saved.after(result5_);
  return output_result;
#endif
}

static variable_list CudnnRnnBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,4> needs_input_grad, size_t weight_size_, bool& batch_first, std::vector<c10::SymInt>& batch_sizes, bool& bidirectional, Tensor& cx, double& dropout, Tensor& dropout_state, c10::SymInt& hidden_size, Tensor& hx, Tensor& input, int64_t& mode, int64_t& num_layers, c10::SymInt& proj_size, bool& train, std::vector<Tensor>& weight, int64_t& weight_stride0, Tensor& result0, Tensor& result3, Tensor& result4, bool retain_variables)
{
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(weight_size_);
  auto hx_ix = gen.range(1);
  auto cx_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[0] || needs_input_grad[2] || needs_input_grad[3] || needs_input_grad[1]) {
      auto grad_input_mask = std::array<bool, 4>{
        needs_input_grad[0],
        needs_input_grad[2],
        needs_input_grad[3],
        needs_input_grad[1],
      };
    auto grad_result = _cudnn_rnn_backward_symint(input, weight, weight_stride0, result4, hx, cx, result0, grads[0], grads[1], grads[2], mode, hidden_size, proj_size, num_layers, batch_first, dropout, train, bidirectional, batch_sizes, dropout_state, retain_variables ? result3.clone() : result3, grad_input_mask);
      if (needs_input_grad[/*input*/0]) {
        copy_range(grad_inputs, input_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*hx*/2]) {
        copy_range(grad_inputs, hx_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*cx*/3]) {
        copy_range(grad_inputs, cx_ix, std::get<2>(grad_result));
      }
      if (needs_input_grad[/*weight*/1]) {
        copy_range(grad_inputs, weight_ix, std::get<3>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list CudnnRnnBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 4>>();
  auto weight_size_ = packed_args.unpack<size_t>();
  auto batch_first = packed_args.unpack<bool>();
  auto batch_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  auto bidirectional = packed_args.unpack<bool>();
  auto cx = packed_args.unpack<Tensor>();
  auto dropout = packed_args.unpack<double>();
  auto dropout_state = packed_args.unpack<Tensor>();
  auto hidden_size = packed_args.unpack<c10::SymInt>();
  auto hx = packed_args.unpack<Tensor>();
  auto input = packed_args.unpack<Tensor>();
  auto mode = packed_args.unpack<int64_t>();
  auto num_layers = packed_args.unpack<int64_t>();
  auto proj_size = packed_args.unpack<c10::SymInt>();
  auto train = packed_args.unpack<bool>();
  auto weight = packed_args.unpack<std::vector<Tensor>>();
  auto weight_stride0 = packed_args.unpack<int64_t>();
  auto result0 = packed_args.unpack<Tensor>();
  auto result3 = packed_args.unpack<Tensor>();
  auto result4 = packed_args.unpack<Tensor>();
  auto retain_variables = packed_args.unpack<bool>();
  return CudnnRnnBackward0_apply_functional(variable_list(grads), needs_input_grad, weight_size_, batch_first, batch_sizes, bidirectional, cx, dropout, dropout_state, hidden_size, hx, input, mode, num_layers, proj_size, train, weight, weight_stride0, result0, result3, result4, retain_variables);
#endif
}

variable_list CudnnRnnBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!weight_released_, ERR_BACKWARD_TWICE);
  auto cx = cx_.unpack();
  auto dropout_state = dropout_state_.unpack();
  auto hx = hx_.unpack();
  auto input = input_.unpack();
  auto weight = unpack_list(weight_, nullptr);
  auto result0 = result0_.unpack(shared_from_this());
  auto result3 = result3_.unpack(shared_from_this());
  auto result4 = result4_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(weight_size_);
  auto hx_ix = gen.range(1);
  auto cx_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 4>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ hx_ix }),
    task_should_compute_output({ cx_ix }),
  };
  return CudnnRnnBackward0_apply_functional(std::move(grads), needs_input_grad, weight_size_, batch_first, batch_sizes, bidirectional, cx, dropout, dropout_state, hidden_size, hx, input, mode, num_layers, proj_size, train, weight, weight_stride0, result0, result3, result4, retain_variables);
}

void CudnnRnnBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(batch_first);
    args.collect(batch_sizes);
    args.collect(bidirectional);
    args.collect(cx_, false);
    args.collect(dropout);
    args.collect(dropout_state_, false);
    args.collect(hidden_size);
    args.collect(hx_, false);
    args.collect(input_, false);
    args.collect(mode);
    args.collect(num_layers);
    args.collect(proj_size);
    args.collect(train);
    args.collect(weight_, false);
    args.collect(weight_stride0);
    args.collect(result0_, true);
    args.collect(result3_, true);
    args.collect(result4_, true);
}
variable_list CudnnRnnBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(batch_first);
  saved.before(batch_sizes);
  saved.before(bidirectional);
  saved.before(cx_);
  saved.before(dropout);
  saved.before(dropout_state_);
  saved.before(hidden_size);
  saved.before(hx_);
  saved.before(input_);
  saved.before(mode);
  saved.before(num_layers);
  saved.before(proj_size);
  saved.before(train);
  saved.before(weight_);
  saved.before(weight_stride0);
  saved.before(result0_);
  saved.before(result3_);
  saved.before(result4_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 4>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<double>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), CudnnRnnBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!weight_released_, ERR_BACKWARD_TWICE);
  auto cx = cx_.unpack();
  auto dropout_state = dropout_state_.unpack();
  auto hx = hx_.unpack();
  auto input = input_.unpack();
  auto weight = unpack_list(weight_, nullptr);
  auto result0 = result0_.unpack(shared_from_this());
  auto result3 = result3_.unpack(shared_from_this());
  auto result4 = result4_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(weight_size_);
  auto hx_ix = gen.range(1);
  auto cx_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 4>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ hx_ix }),
    task_should_compute_output({ cx_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(weight_size_);
  packed_args.pack(batch_first);
  packed_args.pack(batch_sizes);
  packed_args.pack(bidirectional);
  packed_args.pack(cx);
  packed_args.pack(dropout);
  packed_args.pack(dropout_state);
  packed_args.pack(hidden_size);
  packed_args.pack(hx);
  packed_args.pack(input);
  packed_args.pack(mode);
  packed_args.pack(num_layers);
  packed_args.pack(proj_size);
  packed_args.pack(train);
  packed_args.pack(weight);
  packed_args.pack(weight_stride0);
  packed_args.pack(result0);
  packed_args.pack(result3);
  packed_args.pack(result4);
  packed_args.pack(retain_variables);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(batch_first);
  saved.after(batch_sizes);
  saved.after(bidirectional);
  saved.after(cx_);
  saved.after(dropout);
  saved.after(dropout_state_);
  saved.after(hidden_size);
  saved.after(hx_);
  saved.after(input_);
  saved.after(mode);
  saved.after(num_layers);
  saved.after(proj_size);
  saved.after(train);
  saved.after(weight_);
  saved.after(weight_stride0);
  saved.after(result0_);
  saved.after(result3_);
  saved.after(result4_);
  return output_result;
#endif
}

static variable_list CudnnRnnBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,8> needs_input_grad, size_t weight_size_)
{
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(weight_size_);
  auto hx_ix = gen.range(1);
  auto cx_ix = gen.range(1);
  auto output_ix = gen.range(1);
  auto grad_output_ix = gen.range(1);
  auto grad_hy_ix = gen.range(1);
  auto grad_cy_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*cx*/3]) {
    auto grad_result = not_implemented("_cudnn_rnn_backward", kCudnnDoubleBackwardMsg);
    copy_range(grad_inputs, cx_ix, grad_result);
  }
  if (needs_input_grad[/*grad_cy*/7]) {
    auto grad_result = not_implemented("_cudnn_rnn_backward", kCudnnDoubleBackwardMsg);
    copy_range(grad_inputs, grad_cy_ix, grad_result);
  }
  if (needs_input_grad[/*grad_hy*/6]) {
    auto grad_result = not_implemented("_cudnn_rnn_backward", kCudnnDoubleBackwardMsg);
    copy_range(grad_inputs, grad_hy_ix, grad_result);
  }
  if (needs_input_grad[/*grad_output*/5]) {
    auto grad_result = not_implemented("_cudnn_rnn_backward", kCudnnDoubleBackwardMsg);
    copy_range(grad_inputs, grad_output_ix, grad_result);
  }
  if (needs_input_grad[/*hx*/2]) {
    auto grad_result = not_implemented("_cudnn_rnn_backward", kCudnnDoubleBackwardMsg);
    copy_range(grad_inputs, hx_ix, grad_result);
  }
  if (needs_input_grad[/*input*/0]) {
    auto grad_result = not_implemented("_cudnn_rnn_backward", kCudnnDoubleBackwardMsg);
    copy_range(grad_inputs, input_ix, grad_result);
  }
  if (needs_input_grad[/*output*/4]) {
    auto grad_result = not_implemented("_cudnn_rnn_backward", kCudnnDoubleBackwardMsg);
    copy_range(grad_inputs, output_ix, grad_result);
  }
  if (needs_input_grad[/*weight*/1]) {
    auto grad_result = not_implemented_list("_cudnn_rnn_backward", kCudnnDoubleBackwardMsg);
    copy_range(grad_inputs, weight_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list CudnnRnnBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 8>>();
  auto weight_size_ = packed_args.unpack<size_t>();
  return CudnnRnnBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, weight_size_);
#endif
}

variable_list CudnnRnnBackwardBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(weight_size_);
  auto hx_ix = gen.range(1);
  auto cx_ix = gen.range(1);
  auto output_ix = gen.range(1);
  auto grad_output_ix = gen.range(1);
  auto grad_hy_ix = gen.range(1);
  auto grad_cy_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 8>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ hx_ix }),
    task_should_compute_output({ cx_ix }),
    task_should_compute_output({ output_ix }),
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ grad_hy_ix }),
    task_should_compute_output({ grad_cy_ix }),
  };
  return CudnnRnnBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, weight_size_);
}

void CudnnRnnBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list CudnnRnnBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 8>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), CudnnRnnBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(weight_size_);
  auto hx_ix = gen.range(1);
  auto cx_ix = gen.range(1);
  auto output_ix = gen.range(1);
  auto grad_output_ix = gen.range(1);
  auto grad_hy_ix = gen.range(1);
  auto grad_cy_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 8>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ hx_ix }),
    task_should_compute_output({ cx_ix }),
    task_should_compute_output({ output_ix }),
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ grad_hy_ix }),
    task_should_compute_output({ grad_cy_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(weight_size_);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list MiopenConvolutionTransposeBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, c10::OptionalArray<c10::SymInt>& bias_sym_sizes_opt, std::vector<c10::SymInt>& dilation, c10::SymInt& groups, std::vector<c10::SymInt>& output_padding, std::vector<c10::SymInt>& padding, Tensor& self, std::vector<c10::SymInt>& stride, Tensor& weight)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1] || needs_input_grad[2]) {
      auto grad_input_mask = std::array<bool, 3>{
        needs_input_grad[0],
        needs_input_grad[1],
        needs_input_grad[2],
      };
    auto grad_result = grad.defined() ? convolution_backward_symint(grad, self, weight, bias_sym_sizes_opt, stride, padding, dilation, true, output_padding, groups, grad_input_mask) : std::tuple<Tensor, Tensor, Tensor>();
      if (needs_input_grad[/*self*/0]) {
        copy_range(grad_inputs, self_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*weight*/1]) {
        copy_range(grad_inputs, weight_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*bias*/2]) {
        copy_range(grad_inputs, bias_ix, std::get<2>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list MiopenConvolutionTransposeBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto bias_sym_sizes_opt = packed_args.unpack<c10::OptionalArray<c10::SymInt>>();
  auto dilation = packed_args.unpack<std::vector<c10::SymInt>>();
  auto groups = packed_args.unpack<c10::SymInt>();
  auto output_padding = packed_args.unpack<std::vector<c10::SymInt>>();
  auto padding = packed_args.unpack<std::vector<c10::SymInt>>();
  auto self = packed_args.unpack<Tensor>();
  auto stride = packed_args.unpack<std::vector<c10::SymInt>>();
  auto weight = packed_args.unpack<Tensor>();
  return MiopenConvolutionTransposeBackward0_apply_functional(variable_list(grads), needs_input_grad, bias_sym_sizes_opt, dilation, groups, output_padding, padding, self, stride, weight);
#endif
}

variable_list MiopenConvolutionTransposeBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  return MiopenConvolutionTransposeBackward0_apply_functional(std::move(grads), needs_input_grad, bias_sym_sizes_opt, dilation, groups, output_padding, padding, self, stride, weight);
}

void MiopenConvolutionTransposeBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(bias_sym_sizes_opt);
    args.collect(dilation);
    args.collect(groups);
    args.collect(output_padding);
    args.collect(padding);
    args.collect(self_, false);
    args.collect(stride);
    args.collect(weight_, false);
}
variable_list MiopenConvolutionTransposeBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(bias_sym_sizes_opt);
  saved.before(dilation);
  saved.before(groups);
  saved.before(output_padding);
  saved.before(padding);
  saved.before(self_);
  saved.before(stride);
  saved.before(weight_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::OptionalArray<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MiopenConvolutionTransposeBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(bias_sym_sizes_opt);
  packed_args.pack(dilation);
  packed_args.pack(groups);
  packed_args.pack(output_padding);
  packed_args.pack(padding);
  packed_args.pack(self);
  packed_args.pack(stride);
  packed_args.pack(weight);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(bias_sym_sizes_opt);
  saved.after(dilation);
  saved.after(groups);
  saved.after(output_padding);
  saved.after(padding);
  saved.after(self_);
  saved.after(stride);
  saved.after(weight_);
  return output_result;
#endif
}

static variable_list MiopenConvolutionBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, c10::OptionalArray<c10::SymInt>& bias_sym_sizes_opt, std::vector<c10::SymInt>& dilation, c10::SymInt& groups, std::vector<c10::SymInt>& padding, Tensor& self, std::vector<c10::SymInt>& stride, Tensor& weight)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1] || needs_input_grad[2]) {
      auto grad_input_mask = std::array<bool, 3>{
        needs_input_grad[0],
        needs_input_grad[1],
        needs_input_grad[2],
      };
    auto grad_result = grad.defined() ? convolution_backward_symint(grad, self, weight, bias_sym_sizes_opt, stride, padding, dilation, false, std::vector<c10::SymInt>(padding.size(), 0), groups, grad_input_mask) : std::tuple<Tensor, Tensor, Tensor>();
      if (needs_input_grad[/*self*/0]) {
        copy_range(grad_inputs, self_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*weight*/1]) {
        copy_range(grad_inputs, weight_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*bias*/2]) {
        copy_range(grad_inputs, bias_ix, std::get<2>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list MiopenConvolutionBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto bias_sym_sizes_opt = packed_args.unpack<c10::OptionalArray<c10::SymInt>>();
  auto dilation = packed_args.unpack<std::vector<c10::SymInt>>();
  auto groups = packed_args.unpack<c10::SymInt>();
  auto padding = packed_args.unpack<std::vector<c10::SymInt>>();
  auto self = packed_args.unpack<Tensor>();
  auto stride = packed_args.unpack<std::vector<c10::SymInt>>();
  auto weight = packed_args.unpack<Tensor>();
  return MiopenConvolutionBackward0_apply_functional(variable_list(grads), needs_input_grad, bias_sym_sizes_opt, dilation, groups, padding, self, stride, weight);
#endif
}

variable_list MiopenConvolutionBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  return MiopenConvolutionBackward0_apply_functional(std::move(grads), needs_input_grad, bias_sym_sizes_opt, dilation, groups, padding, self, stride, weight);
}

void MiopenConvolutionBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(bias_sym_sizes_opt);
    args.collect(dilation);
    args.collect(groups);
    args.collect(padding);
    args.collect(self_, false);
    args.collect(stride);
    args.collect(weight_, false);
}
variable_list MiopenConvolutionBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(bias_sym_sizes_opt);
  saved.before(dilation);
  saved.before(groups);
  saved.before(padding);
  saved.before(self_);
  saved.before(stride);
  saved.before(weight_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::OptionalArray<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MiopenConvolutionBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(bias_sym_sizes_opt);
  packed_args.pack(dilation);
  packed_args.pack(groups);
  packed_args.pack(padding);
  packed_args.pack(self);
  packed_args.pack(stride);
  packed_args.pack(weight);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(bias_sym_sizes_opt);
  saved.after(dilation);
  saved.after(groups);
  saved.after(padding);
  saved.after(self_);
  saved.after(stride);
  saved.after(weight_);
  return output_result;
#endif
}

static variable_list MiopenDepthwiseConvolutionBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, c10::OptionalArray<c10::SymInt>& bias_sym_sizes_opt, std::vector<c10::SymInt>& dilation, c10::SymInt& groups, std::vector<c10::SymInt>& padding, Tensor& self, std::vector<c10::SymInt>& stride, Tensor& weight)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1] || needs_input_grad[2]) {
      auto grad_input_mask = std::array<bool, 3>{
        needs_input_grad[0],
        needs_input_grad[1],
        needs_input_grad[2],
      };
    auto grad_result = grad.defined() ? convolution_backward_symint(grad, self, weight, bias_sym_sizes_opt, stride, padding, dilation, false, std::vector<c10::SymInt>(padding.size(), 0), groups, grad_input_mask) : std::tuple<Tensor, Tensor, Tensor>();
      if (needs_input_grad[/*self*/0]) {
        copy_range(grad_inputs, self_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*weight*/1]) {
        copy_range(grad_inputs, weight_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*bias*/2]) {
        copy_range(grad_inputs, bias_ix, std::get<2>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list MiopenDepthwiseConvolutionBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto bias_sym_sizes_opt = packed_args.unpack<c10::OptionalArray<c10::SymInt>>();
  auto dilation = packed_args.unpack<std::vector<c10::SymInt>>();
  auto groups = packed_args.unpack<c10::SymInt>();
  auto padding = packed_args.unpack<std::vector<c10::SymInt>>();
  auto self = packed_args.unpack<Tensor>();
  auto stride = packed_args.unpack<std::vector<c10::SymInt>>();
  auto weight = packed_args.unpack<Tensor>();
  return MiopenDepthwiseConvolutionBackward0_apply_functional(variable_list(grads), needs_input_grad, bias_sym_sizes_opt, dilation, groups, padding, self, stride, weight);
#endif
}

variable_list MiopenDepthwiseConvolutionBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  return MiopenDepthwiseConvolutionBackward0_apply_functional(std::move(grads), needs_input_grad, bias_sym_sizes_opt, dilation, groups, padding, self, stride, weight);
}

void MiopenDepthwiseConvolutionBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(bias_sym_sizes_opt);
    args.collect(dilation);
    args.collect(groups);
    args.collect(padding);
    args.collect(self_, false);
    args.collect(stride);
    args.collect(weight_, false);
}
variable_list MiopenDepthwiseConvolutionBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(bias_sym_sizes_opt);
  saved.before(dilation);
  saved.before(groups);
  saved.before(padding);
  saved.before(self_);
  saved.before(stride);
  saved.before(weight_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::OptionalArray<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MiopenDepthwiseConvolutionBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(bias_sym_sizes_opt);
  packed_args.pack(dilation);
  packed_args.pack(groups);
  packed_args.pack(padding);
  packed_args.pack(self);
  packed_args.pack(stride);
  packed_args.pack(weight);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(bias_sym_sizes_opt);
  saved.after(dilation);
  saved.after(groups);
  saved.after(padding);
  saved.after(self_);
  saved.after(stride);
  saved.after(weight_);
  return output_result;
#endif
}

static variable_list MiopenBatchNormBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, double& epsilon, Tensor& input, Tensor& running_mean, Tensor& running_var, bool& training, Tensor& weight, Tensor& result1, Tensor& result2)
{
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1] || needs_input_grad[2]) {
      auto grad_input_mask = std::array<bool, 3>{
        needs_input_grad[0],
        needs_input_grad[1],
        needs_input_grad[2],
      };
    auto grad_result = grad.defined() ? (training ? miopen_batch_norm_backward(input, grad.contiguous(), weight, running_mean, running_var, result1, result2, epsilon) : native_batch_norm_backward(grad, input, weight, running_mean, running_var, result1, result2, training, epsilon, grad_input_mask)) : std::tuple<Tensor, Tensor, Tensor>();
      if (needs_input_grad[/*input*/0]) {
        copy_range(grad_inputs, input_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*weight*/1]) {
        copy_range(grad_inputs, weight_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*bias*/2]) {
        copy_range(grad_inputs, bias_ix, std::get<2>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list MiopenBatchNormBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto epsilon = packed_args.unpack<double>();
  auto input = packed_args.unpack<Tensor>();
  auto running_mean = packed_args.unpack<Tensor>();
  auto running_var = packed_args.unpack<Tensor>();
  auto training = packed_args.unpack<bool>();
  auto weight = packed_args.unpack<Tensor>();
  auto result1 = packed_args.unpack<Tensor>();
  auto result2 = packed_args.unpack<Tensor>();
  return MiopenBatchNormBackward0_apply_functional(variable_list(grads), needs_input_grad, epsilon, input, running_mean, running_var, training, weight, result1, result2);
#endif
}

variable_list MiopenBatchNormBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto input = input_.unpack();
  auto running_mean = running_mean_.unpack();
  auto running_var = running_var_.unpack();
  auto weight = weight_.unpack();
  auto result1 = result1_.unpack(shared_from_this());
  auto result2 = result2_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  return MiopenBatchNormBackward0_apply_functional(std::move(grads), needs_input_grad, epsilon, input, running_mean, running_var, training, weight, result1, result2);
}

void MiopenBatchNormBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(epsilon);
    args.collect(input_, false);
    args.collect(running_mean_, false);
    args.collect(running_var_, false);
    args.collect(training);
    args.collect(weight_, false);
    args.collect(result1_, true);
    args.collect(result2_, true);
}
variable_list MiopenBatchNormBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(epsilon);
  saved.before(input_);
  saved.before(running_mean_);
  saved.before(running_var_);
  saved.before(training);
  saved.before(weight_);
  saved.before(result1_);
  saved.before(result2_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<double>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MiopenBatchNormBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto input = input_.unpack();
  auto running_mean = running_mean_.unpack();
  auto running_var = running_var_.unpack();
  auto weight = weight_.unpack();
  auto result1 = result1_.unpack(shared_from_this());
  auto result2 = result2_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(epsilon);
  packed_args.pack(input);
  packed_args.pack(running_mean);
  packed_args.pack(running_var);
  packed_args.pack(training);
  packed_args.pack(weight);
  packed_args.pack(result1);
  packed_args.pack(result2);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(epsilon);
  saved.after(input_);
  saved.after(running_mean_);
  saved.after(running_var_);
  saved.after(training);
  saved.after(weight_);
  saved.after(result1_);
  saved.after(result2_);
  return output_result;
#endif
}

static variable_list MiopenBatchNormBackwardBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,5> needs_input_grad, double& epsilon, Tensor& grad_output, Tensor& input, Tensor& running_mean, Tensor& running_var, Tensor& save_mean, Tensor& save_var, Tensor& weight)
{
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto grad_output_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto save_mean_ix = gen.range(1);
  auto save_var_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[0] || needs_input_grad[2] || needs_input_grad[1]) {
      auto grad_input_mask = std::array<bool, 3>{
        needs_input_grad[0],
        needs_input_grad[2],
        needs_input_grad[1],
      };
    auto grad_result = batchnorm_double_backward(input, weight, grads[0], grads[1], grads[2], grad_output, running_mean, running_var, true, epsilon, save_mean, save_var, grad_input_mask);
      if (needs_input_grad[/*input*/0]) {
        copy_range(grad_inputs, input_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*weight*/2]) {
        copy_range(grad_inputs, weight_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*grad_output*/1]) {
        copy_range(grad_inputs, grad_output_ix, std::get<2>(grad_result));
      }
  }
  if (needs_input_grad[/*save_mean*/3]) {
    auto grad_result = not_implemented("miopen_batch_norm_backward save_mean");
    copy_range(grad_inputs, save_mean_ix, grad_result);
  }
  if (needs_input_grad[/*save_var*/4]) {
    auto grad_result = not_implemented("miopen_batch_norm_backward save_var");
    copy_range(grad_inputs, save_var_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list MiopenBatchNormBackwardBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 5>>();
  auto epsilon = packed_args.unpack<double>();
  auto grad_output = packed_args.unpack<Tensor>();
  auto input = packed_args.unpack<Tensor>();
  auto running_mean = packed_args.unpack<Tensor>();
  auto running_var = packed_args.unpack<Tensor>();
  auto save_mean = packed_args.unpack<Tensor>();
  auto save_var = packed_args.unpack<Tensor>();
  auto weight = packed_args.unpack<Tensor>();
  return MiopenBatchNormBackwardBackward0_apply_functional(variable_list(grads), needs_input_grad, epsilon, grad_output, input, running_mean, running_var, save_mean, save_var, weight);
#endif
}

variable_list MiopenBatchNormBackwardBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto grad_output = grad_output_.unpack();
  auto input = input_.unpack();
  auto running_mean = running_mean_.unpack();
  auto running_var = running_var_.unpack();
  auto save_mean = save_mean_.unpack();
  auto save_var = save_var_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto grad_output_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto save_mean_ix = gen.range(1);
  auto save_var_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 5>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ save_mean_ix }),
    task_should_compute_output({ save_var_ix }),
  };
  return MiopenBatchNormBackwardBackward0_apply_functional(std::move(grads), needs_input_grad, epsilon, grad_output, input, running_mean, running_var, save_mean, save_var, weight);
}

void MiopenBatchNormBackwardBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(epsilon);
    args.collect(grad_output_, false);
    args.collect(input_, false);
    args.collect(running_mean_, false);
    args.collect(running_var_, false);
    args.collect(save_mean_, false);
    args.collect(save_var_, false);
    args.collect(weight_, false);
}
variable_list MiopenBatchNormBackwardBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(epsilon);
  saved.before(grad_output_);
  saved.before(input_);
  saved.before(running_mean_);
  saved.before(running_var_);
  saved.before(save_mean_);
  saved.before(save_var_);
  saved.before(weight_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 5>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<double>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MiopenBatchNormBackwardBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto grad_output = grad_output_.unpack();
  auto input = input_.unpack();
  auto running_mean = running_mean_.unpack();
  auto running_var = running_var_.unpack();
  auto save_mean = save_mean_.unpack();
  auto save_var = save_var_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto grad_output_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto save_mean_ix = gen.range(1);
  auto save_var_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 5>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ grad_output_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ save_mean_ix }),
    task_should_compute_output({ save_var_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(epsilon);
  packed_args.pack(grad_output);
  packed_args.pack(input);
  packed_args.pack(running_mean);
  packed_args.pack(running_var);
  packed_args.pack(save_mean);
  packed_args.pack(save_var);
  packed_args.pack(weight);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(epsilon);
  saved.after(grad_output_);
  saved.after(input_);
  saved.after(running_mean_);
  saved.after(running_var_);
  saved.after(save_mean_);
  saved.after(save_var_);
  saved.after(weight_);
  return output_result;
#endif
}

static variable_list MiopenRnnBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,4> needs_input_grad, size_t weight_size_, bool& batch_first, std::vector<int64_t>& batch_sizes, bool& bidirectional, Tensor& cx, double& dropout, Tensor& dropout_state, int64_t& hidden_size, Tensor& hx, Tensor& input, int64_t& mode, int64_t& num_layers, bool& train, std::vector<Tensor>& weight, int64_t& weight_stride0, Tensor& result0, Tensor& result3, Tensor& result4, bool retain_variables)
{
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(weight_size_);
  auto hx_ix = gen.range(1);
  auto cx_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[0] || needs_input_grad[2] || needs_input_grad[3] || needs_input_grad[1]) {
      auto grad_input_mask = std::array<bool, 4>{
        needs_input_grad[0],
        needs_input_grad[2],
        needs_input_grad[3],
        needs_input_grad[1],
      };
    auto grad_result = miopen_rnn_backward(input, weight, weight_stride0, result4, hx, cx, result0, grads[0], grads[1], grads[2], mode, hidden_size, num_layers, batch_first, dropout, train, bidirectional, batch_sizes, dropout_state, retain_variables ? result3.clone() : result3, grad_input_mask);
      if (needs_input_grad[/*input*/0]) {
        copy_range(grad_inputs, input_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*hx*/2]) {
        copy_range(grad_inputs, hx_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*cx*/3]) {
        copy_range(grad_inputs, cx_ix, std::get<2>(grad_result));
      }
      if (needs_input_grad[/*weight*/1]) {
        copy_range(grad_inputs, weight_ix, std::get<3>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list MiopenRnnBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 4>>();
  auto weight_size_ = packed_args.unpack<size_t>();
  auto batch_first = packed_args.unpack<bool>();
  auto batch_sizes = packed_args.unpack<std::vector<int64_t>>();
  auto bidirectional = packed_args.unpack<bool>();
  auto cx = packed_args.unpack<Tensor>();
  auto dropout = packed_args.unpack<double>();
  auto dropout_state = packed_args.unpack<Tensor>();
  auto hidden_size = packed_args.unpack<int64_t>();
  auto hx = packed_args.unpack<Tensor>();
  auto input = packed_args.unpack<Tensor>();
  auto mode = packed_args.unpack<int64_t>();
  auto num_layers = packed_args.unpack<int64_t>();
  auto train = packed_args.unpack<bool>();
  auto weight = packed_args.unpack<std::vector<Tensor>>();
  auto weight_stride0 = packed_args.unpack<int64_t>();
  auto result0 = packed_args.unpack<Tensor>();
  auto result3 = packed_args.unpack<Tensor>();
  auto result4 = packed_args.unpack<Tensor>();
  auto retain_variables = packed_args.unpack<bool>();
  return MiopenRnnBackward0_apply_functional(variable_list(grads), needs_input_grad, weight_size_, batch_first, batch_sizes, bidirectional, cx, dropout, dropout_state, hidden_size, hx, input, mode, num_layers, train, weight, weight_stride0, result0, result3, result4, retain_variables);
#endif
}

variable_list MiopenRnnBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!weight_released_, ERR_BACKWARD_TWICE);
  auto cx = cx_.unpack();
  auto dropout_state = dropout_state_.unpack();
  auto hx = hx_.unpack();
  auto input = input_.unpack();
  auto weight = unpack_list(weight_, nullptr);
  auto result0 = result0_.unpack(shared_from_this());
  auto result3 = result3_.unpack(shared_from_this());
  auto result4 = result4_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(weight_size_);
  auto hx_ix = gen.range(1);
  auto cx_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 4>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ hx_ix }),
    task_should_compute_output({ cx_ix }),
  };
  return MiopenRnnBackward0_apply_functional(std::move(grads), needs_input_grad, weight_size_, batch_first, batch_sizes, bidirectional, cx, dropout, dropout_state, hidden_size, hx, input, mode, num_layers, train, weight, weight_stride0, result0, result3, result4, retain_variables);
}

void MiopenRnnBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(batch_first);
    args.collect(batch_sizes);
    args.collect(bidirectional);
    args.collect(cx_, false);
    args.collect(dropout);
    args.collect(dropout_state_, false);
    args.collect(hidden_size);
    args.collect(hx_, false);
    args.collect(input_, false);
    args.collect(mode);
    args.collect(num_layers);
    args.collect(train);
    args.collect(weight_, false);
    args.collect(weight_stride0);
    args.collect(result0_, true);
    args.collect(result3_, true);
    args.collect(result4_, true);
}
variable_list MiopenRnnBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(batch_first);
  saved.before(batch_sizes);
  saved.before(bidirectional);
  saved.before(cx_);
  saved.before(dropout);
  saved.before(dropout_state_);
  saved.before(hidden_size);
  saved.before(hx_);
  saved.before(input_);
  saved.before(mode);
  saved.before(num_layers);
  saved.before(train);
  saved.before(weight_);
  saved.before(weight_stride0);
  saved.before(result0_);
  saved.before(result3_);
  saved.before(result4_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 4>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<double>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MiopenRnnBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!weight_released_, ERR_BACKWARD_TWICE);
  auto cx = cx_.unpack();
  auto dropout_state = dropout_state_.unpack();
  auto hx = hx_.unpack();
  auto input = input_.unpack();
  auto weight = unpack_list(weight_, nullptr);
  auto result0 = result0_.unpack(shared_from_this());
  auto result3 = result3_.unpack(shared_from_this());
  auto result4 = result4_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight_ix = gen.range(weight_size_);
  auto hx_ix = gen.range(1);
  auto cx_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 4>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ hx_ix }),
    task_should_compute_output({ cx_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(weight_size_);
  packed_args.pack(batch_first);
  packed_args.pack(batch_sizes);
  packed_args.pack(bidirectional);
  packed_args.pack(cx);
  packed_args.pack(dropout);
  packed_args.pack(dropout_state);
  packed_args.pack(hidden_size);
  packed_args.pack(hx);
  packed_args.pack(input);
  packed_args.pack(mode);
  packed_args.pack(num_layers);
  packed_args.pack(train);
  packed_args.pack(weight);
  packed_args.pack(weight_stride0);
  packed_args.pack(result0);
  packed_args.pack(result3);
  packed_args.pack(result4);
  packed_args.pack(retain_variables);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(batch_first);
  saved.after(batch_sizes);
  saved.after(bidirectional);
  saved.after(cx_);
  saved.after(dropout);
  saved.after(dropout_state_);
  saved.after(hidden_size);
  saved.after(hx_);
  saved.after(input_);
  saved.after(mode);
  saved.after(num_layers);
  saved.after(train);
  saved.after(weight_);
  saved.after(weight_stride0);
  saved.after(result0_);
  saved.after(result3_);
  saved.after(result4_);
  return output_result;
#endif
}

static variable_list MkldnnRnnLayerBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,7> needs_input_grad, bool& batch_first, std::vector<int64_t>& batch_sizes, bool& bidirectional, Tensor& cx_, bool& has_biases, int64_t& hidden_size, Tensor& hx_, Tensor& input, int64_t& mode, int64_t& num_layers, bool& reverse, bool& train, Tensor& weight0, Tensor& weight1, Tensor& weight2, Tensor& weight3, Tensor& result0, Tensor& result1, Tensor& result2, Tensor& result3)
{
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight0_ix = gen.range(1);
  auto weight1_ix = gen.range(1);
  auto weight2_ix = gen.range(1);
  auto weight3_ix = gen.range(1);
  auto hx__ix = gen.range(1);
  auto cx__ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[0] || needs_input_grad[1] || needs_input_grad[2] || needs_input_grad[3] || needs_input_grad[4] || needs_input_grad[5] || needs_input_grad[6]) {
  
    auto grad_result = GradMode::is_enabled() ? mkldnn_rnn_layer_differentiable_backward(input, weight0, weight1, weight2, weight3, hx_, cx_, result0, result1, result2, grads[0], grads[1], grads[2], reverse, mode, hidden_size, num_layers, has_biases, train, bidirectional, batch_sizes, batch_first, result3) : mkldnn_rnn_layer_backward(input, weight0, weight1, weight2, weight3, hx_, cx_, result0, result1, result2, grads[0], grads[1], grads[2], reverse, mode, hidden_size, num_layers, has_biases, train, bidirectional, batch_sizes, batch_first, result3);
      if (needs_input_grad[/*input*/0]) {
        copy_range(grad_inputs, input_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*weight0*/1]) {
        copy_range(grad_inputs, weight0_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*weight1*/2]) {
        copy_range(grad_inputs, weight1_ix, std::get<2>(grad_result));
      }
      if (needs_input_grad[/*weight2*/3]) {
        copy_range(grad_inputs, weight2_ix, std::get<3>(grad_result));
      }
      if (needs_input_grad[/*weight3*/4]) {
        copy_range(grad_inputs, weight3_ix, std::get<4>(grad_result));
      }
      if (needs_input_grad[/*hx_*/5]) {
        copy_range(grad_inputs, hx__ix, std::get<5>(grad_result));
      }
      if (needs_input_grad[/*cx_*/6]) {
        copy_range(grad_inputs, cx__ix, std::get<6>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list MkldnnRnnLayerBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 7>>();
  auto batch_first = packed_args.unpack<bool>();
  auto batch_sizes = packed_args.unpack<std::vector<int64_t>>();
  auto bidirectional = packed_args.unpack<bool>();
  auto cx_ = packed_args.unpack<Tensor>();
  auto has_biases = packed_args.unpack<bool>();
  auto hidden_size = packed_args.unpack<int64_t>();
  auto hx_ = packed_args.unpack<Tensor>();
  auto input = packed_args.unpack<Tensor>();
  auto mode = packed_args.unpack<int64_t>();
  auto num_layers = packed_args.unpack<int64_t>();
  auto reverse = packed_args.unpack<bool>();
  auto train = packed_args.unpack<bool>();
  auto weight0 = packed_args.unpack<Tensor>();
  auto weight1 = packed_args.unpack<Tensor>();
  auto weight2 = packed_args.unpack<Tensor>();
  auto weight3 = packed_args.unpack<Tensor>();
  auto result0 = packed_args.unpack<Tensor>();
  auto result1 = packed_args.unpack<Tensor>();
  auto result2 = packed_args.unpack<Tensor>();
  auto result3 = packed_args.unpack<Tensor>();
  return MkldnnRnnLayerBackward0_apply_functional(variable_list(grads), needs_input_grad, batch_first, batch_sizes, bidirectional, cx_, has_biases, hidden_size, hx_, input, mode, num_layers, reverse, train, weight0, weight1, weight2, weight3, result0, result1, result2, result3);
#endif
}

variable_list MkldnnRnnLayerBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto cx_ = cx__.unpack();
  auto hx_ = hx__.unpack();
  auto input = input_.unpack();
  auto weight0 = weight0_.unpack();
  auto weight1 = weight1_.unpack();
  auto weight2 = weight2_.unpack();
  auto weight3 = weight3_.unpack();
  auto result0 = result0_.unpack(shared_from_this());
  auto result1 = result1_.unpack(shared_from_this());
  auto result2 = result2_.unpack(shared_from_this());
  auto result3 = result3_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight0_ix = gen.range(1);
  auto weight1_ix = gen.range(1);
  auto weight2_ix = gen.range(1);
  auto weight3_ix = gen.range(1);
  auto hx__ix = gen.range(1);
  auto cx__ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 7>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ weight0_ix }),
    task_should_compute_output({ weight1_ix }),
    task_should_compute_output({ weight2_ix }),
    task_should_compute_output({ weight3_ix }),
    task_should_compute_output({ hx__ix }),
    task_should_compute_output({ cx__ix }),
  };
  return MkldnnRnnLayerBackward0_apply_functional(std::move(grads), needs_input_grad, batch_first, batch_sizes, bidirectional, cx_, has_biases, hidden_size, hx_, input, mode, num_layers, reverse, train, weight0, weight1, weight2, weight3, result0, result1, result2, result3);
}

void MkldnnRnnLayerBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(batch_first);
    args.collect(batch_sizes);
    args.collect(bidirectional);
    args.collect(cx__, false);
    args.collect(has_biases);
    args.collect(hidden_size);
    args.collect(hx__, false);
    args.collect(input_, false);
    args.collect(mode);
    args.collect(num_layers);
    args.collect(reverse);
    args.collect(train);
    args.collect(weight0_, false);
    args.collect(weight1_, false);
    args.collect(weight2_, false);
    args.collect(weight3_, false);
    args.collect(result0_, true);
    args.collect(result1_, true);
    args.collect(result2_, true);
    args.collect(result3_, true);
}
variable_list MkldnnRnnLayerBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(batch_first);
  saved.before(batch_sizes);
  saved.before(bidirectional);
  saved.before(cx__);
  saved.before(has_biases);
  saved.before(hidden_size);
  saved.before(hx__);
  saved.before(input_);
  saved.before(mode);
  saved.before(num_layers);
  saved.before(reverse);
  saved.before(train);
  saved.before(weight0_);
  saved.before(weight1_);
  saved.before(weight2_);
  saved.before(weight3_);
  saved.before(result0_);
  saved.before(result1_);
  saved.before(result2_);
  saved.before(result3_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 7>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MkldnnRnnLayerBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto cx_ = cx__.unpack();
  auto hx_ = hx__.unpack();
  auto input = input_.unpack();
  auto weight0 = weight0_.unpack();
  auto weight1 = weight1_.unpack();
  auto weight2 = weight2_.unpack();
  auto weight3 = weight3_.unpack();
  auto result0 = result0_.unpack(shared_from_this());
  auto result1 = result1_.unpack(shared_from_this());
  auto result2 = result2_.unpack(shared_from_this());
  auto result3 = result3_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto weight0_ix = gen.range(1);
  auto weight1_ix = gen.range(1);
  auto weight2_ix = gen.range(1);
  auto weight3_ix = gen.range(1);
  auto hx__ix = gen.range(1);
  auto cx__ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 7>{
    task_should_compute_output({ input_ix }),
    task_should_compute_output({ weight0_ix }),
    task_should_compute_output({ weight1_ix }),
    task_should_compute_output({ weight2_ix }),
    task_should_compute_output({ weight3_ix }),
    task_should_compute_output({ hx__ix }),
    task_should_compute_output({ cx__ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(batch_first);
  packed_args.pack(batch_sizes);
  packed_args.pack(bidirectional);
  packed_args.pack(cx_);
  packed_args.pack(has_biases);
  packed_args.pack(hidden_size);
  packed_args.pack(hx_);
  packed_args.pack(input);
  packed_args.pack(mode);
  packed_args.pack(num_layers);
  packed_args.pack(reverse);
  packed_args.pack(train);
  packed_args.pack(weight0);
  packed_args.pack(weight1);
  packed_args.pack(weight2);
  packed_args.pack(weight3);
  packed_args.pack(result0);
  packed_args.pack(result1);
  packed_args.pack(result2);
  packed_args.pack(result3);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(batch_first);
  saved.after(batch_sizes);
  saved.after(bidirectional);
  saved.after(cx__);
  saved.after(has_biases);
  saved.after(hidden_size);
  saved.after(hx__);
  saved.after(input_);
  saved.after(mode);
  saved.after(num_layers);
  saved.after(reverse);
  saved.after(train);
  saved.after(weight0_);
  saved.after(weight1_);
  saved.after(weight2_);
  saved.after(weight3_);
  saved.after(result0_);
  saved.after(result1_);
  saved.after(result2_);
  saved.after(result3_);
  return output_result;
#endif
}

static variable_list MkldnnConvolutionBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, c10::OptionalArray<c10::SymInt>& bias_sym_sizes_opt, std::vector<c10::SymInt>& dilation, c10::SymInt& groups, std::vector<c10::SymInt>& padding, Tensor& self, std::vector<c10::SymInt>& stride, Tensor& weight)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1] || needs_input_grad[2]) {
      auto grad_input_mask = std::array<bool, 3>{
        needs_input_grad[0],
        needs_input_grad[1],
        needs_input_grad[2],
      };
    auto grad_result = grad.defined() ? convolution_backward_symint(grad, self, weight, bias_sym_sizes_opt, stride, padding, dilation, /*transposed=*/ false, /*output_padding=*/ std::vector<c10::SymInt>(padding.size(), 0), groups, grad_input_mask) : std::tuple<Tensor, Tensor, Tensor>();
      if (needs_input_grad[/*self*/0]) {
        copy_range(grad_inputs, self_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*weight*/1]) {
        copy_range(grad_inputs, weight_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*bias*/2]) {
        copy_range(grad_inputs, bias_ix, std::get<2>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list MkldnnConvolutionBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto bias_sym_sizes_opt = packed_args.unpack<c10::OptionalArray<c10::SymInt>>();
  auto dilation = packed_args.unpack<std::vector<c10::SymInt>>();
  auto groups = packed_args.unpack<c10::SymInt>();
  auto padding = packed_args.unpack<std::vector<c10::SymInt>>();
  auto self = packed_args.unpack<Tensor>();
  auto stride = packed_args.unpack<std::vector<c10::SymInt>>();
  auto weight = packed_args.unpack<Tensor>();
  return MkldnnConvolutionBackward0_apply_functional(variable_list(grads), needs_input_grad, bias_sym_sizes_opt, dilation, groups, padding, self, stride, weight);
#endif
}

variable_list MkldnnConvolutionBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  return MkldnnConvolutionBackward0_apply_functional(std::move(grads), needs_input_grad, bias_sym_sizes_opt, dilation, groups, padding, self, stride, weight);
}

void MkldnnConvolutionBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(bias_sym_sizes_opt);
    args.collect(dilation);
    args.collect(groups);
    args.collect(padding);
    args.collect(self_, false);
    args.collect(stride);
    args.collect(weight_, false);
}
variable_list MkldnnConvolutionBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(bias_sym_sizes_opt);
  saved.before(dilation);
  saved.before(groups);
  saved.before(padding);
  saved.before(self_);
  saved.before(stride);
  saved.before(weight_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::OptionalArray<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MkldnnConvolutionBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(bias_sym_sizes_opt);
  packed_args.pack(dilation);
  packed_args.pack(groups);
  packed_args.pack(padding);
  packed_args.pack(self);
  packed_args.pack(stride);
  packed_args.pack(weight);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(bias_sym_sizes_opt);
  saved.after(dilation);
  saved.after(groups);
  saved.after(padding);
  saved.after(self_);
  saved.after(stride);
  saved.after(weight_);
  return output_result;
#endif
}

static variable_list MkldnnLinearBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, Tensor& self, Tensor& weight)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1] || needs_input_grad[2]) {
      auto grad_input_mask = std::array<bool, 3>{
        needs_input_grad[0],
        needs_input_grad[1],
        needs_input_grad[2],
      };
    auto grad_result = mkldnn_linear_backward(self, grad, weight, grad_input_mask);
      if (needs_input_grad[/*self*/0]) {
        copy_range(grad_inputs, self_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*weight*/1]) {
        copy_range(grad_inputs, weight_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*bias*/2]) {
        copy_range(grad_inputs, bias_ix, std::get<2>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list MkldnnLinearBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto self = packed_args.unpack<Tensor>();
  auto weight = packed_args.unpack<Tensor>();
  return MkldnnLinearBackward0_apply_functional(variable_list(grads), needs_input_grad, self, weight);
#endif
}

variable_list MkldnnLinearBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  return MkldnnLinearBackward0_apply_functional(std::move(grads), needs_input_grad, self, weight);
}

void MkldnnLinearBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
    args.collect(weight_, false);
}
variable_list MkldnnLinearBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);
  saved.before(weight_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MkldnnLinearBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto weight = weight_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto weight_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ weight_ix }),
    task_should_compute_output({ bias_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);
  packed_args.pack(weight);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  saved.after(weight_);
  return output_result;
#endif
}

static variable_list MkldnnMaxPool2DBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, bool& ceil_mode, std::vector<int64_t>& dilation, std::vector<int64_t>& kernel_size, std::vector<int64_t>& padding, Tensor& self, std::vector<int64_t>& stride, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (mkldnn_max_pool2d_backward(grad, result, self, kernel_size, stride, padding, dilation, ceil_mode)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list MkldnnMaxPool2DBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto ceil_mode = packed_args.unpack<bool>();
  auto dilation = packed_args.unpack<std::vector<int64_t>>();
  auto kernel_size = packed_args.unpack<std::vector<int64_t>>();
  auto padding = packed_args.unpack<std::vector<int64_t>>();
  auto self = packed_args.unpack<Tensor>();
  auto stride = packed_args.unpack<std::vector<int64_t>>();
  auto result = packed_args.unpack<Tensor>();
  return MkldnnMaxPool2DBackward0_apply_functional(variable_list(grads), needs_input_grad, ceil_mode, dilation, kernel_size, padding, self, stride, result);
#endif
}

variable_list MkldnnMaxPool2DBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return MkldnnMaxPool2DBackward0_apply_functional(std::move(grads), needs_input_grad, ceil_mode, dilation, kernel_size, padding, self, stride, result);
}

void MkldnnMaxPool2DBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(ceil_mode);
    args.collect(dilation);
    args.collect(kernel_size);
    args.collect(padding);
    args.collect(self_, false);
    args.collect(stride);
    args.collect(result_, true);
}
variable_list MkldnnMaxPool2DBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(ceil_mode);
  saved.before(dilation);
  saved.before(kernel_size);
  saved.before(padding);
  saved.before(self_);
  saved.before(stride);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MkldnnMaxPool2DBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(ceil_mode);
  packed_args.pack(dilation);
  packed_args.pack(kernel_size);
  packed_args.pack(padding);
  packed_args.pack(self);
  packed_args.pack(stride);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(ceil_mode);
  saved.after(dilation);
  saved.after(kernel_size);
  saved.after(padding);
  saved.after(self_);
  saved.after(stride);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list MkldnnMaxPool3DBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, bool& ceil_mode, std::vector<int64_t>& dilation, std::vector<int64_t>& kernel_size, std::vector<int64_t>& padding, Tensor& self, std::vector<int64_t>& stride, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (mkldnn_max_pool3d_backward(grad, result, self, kernel_size, stride, padding, dilation, ceil_mode)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list MkldnnMaxPool3DBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto ceil_mode = packed_args.unpack<bool>();
  auto dilation = packed_args.unpack<std::vector<int64_t>>();
  auto kernel_size = packed_args.unpack<std::vector<int64_t>>();
  auto padding = packed_args.unpack<std::vector<int64_t>>();
  auto self = packed_args.unpack<Tensor>();
  auto stride = packed_args.unpack<std::vector<int64_t>>();
  auto result = packed_args.unpack<Tensor>();
  return MkldnnMaxPool3DBackward0_apply_functional(variable_list(grads), needs_input_grad, ceil_mode, dilation, kernel_size, padding, self, stride, result);
#endif
}

variable_list MkldnnMaxPool3DBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return MkldnnMaxPool3DBackward0_apply_functional(std::move(grads), needs_input_grad, ceil_mode, dilation, kernel_size, padding, self, stride, result);
}

void MkldnnMaxPool3DBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(ceil_mode);
    args.collect(dilation);
    args.collect(kernel_size);
    args.collect(padding);
    args.collect(self_, false);
    args.collect(stride);
    args.collect(result_, true);
}
variable_list MkldnnMaxPool3DBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(ceil_mode);
  saved.before(dilation);
  saved.before(kernel_size);
  saved.before(padding);
  saved.before(self_);
  saved.before(stride);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MkldnnMaxPool3DBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(ceil_mode);
  packed_args.pack(dilation);
  packed_args.pack(kernel_size);
  packed_args.pack(padding);
  packed_args.pack(self);
  packed_args.pack(stride);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(ceil_mode);
  saved.after(dilation);
  saved.after(kernel_size);
  saved.after(padding);
  saved.after(self_);
  saved.after(stride);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list MkldnnAdaptiveAvgPool2DBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (mkldnn_adaptive_avg_pool2d_backward(grad, self)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list MkldnnAdaptiveAvgPool2DBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  return MkldnnAdaptiveAvgPool2DBackward0_apply_functional(variable_list(grads), needs_input_grad, self);
#endif
}

variable_list MkldnnAdaptiveAvgPool2DBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return MkldnnAdaptiveAvgPool2DBackward0_apply_functional(std::move(grads), needs_input_grad, self);
}

void MkldnnAdaptiveAvgPool2DBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list MkldnnAdaptiveAvgPool2DBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MkldnnAdaptiveAvgPool2DBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list MkldnnReshapeBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<c10::SymInt>& self_sym_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.reshape_symint(self_sym_sizes)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list MkldnnReshapeBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return MkldnnReshapeBackward0_apply_functional(variable_list(grads), needs_input_grad, self_sym_sizes);
#endif
}

variable_list MkldnnReshapeBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return MkldnnReshapeBackward0_apply_functional(std::move(grads), needs_input_grad, self_sym_sizes);
}

void MkldnnReshapeBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_sym_sizes);
}
variable_list MkldnnReshapeBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), MkldnnReshapeBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_sym_sizes);
  return output_result;
#endif
}

static variable_list NestedTensorFromTensorListBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t list_size_, std::vector<Tensor>& list)
{
  IndexRangeGenerator gen;
  auto list_ix = gen.range(list_size_);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[/*list*/0]) {
    auto grad_result = grad.defined()? at::unbind(grad) : std::vector<Tensor>(list.size());
    copy_range(grad_inputs, list_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list NestedTensorFromTensorListBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto list_size_ = packed_args.unpack<size_t>();
  auto list = packed_args.unpack<std::vector<Tensor>>();
  return NestedTensorFromTensorListBackward0_apply_functional(variable_list(grads), needs_input_grad, list_size_, list);
#endif
}

variable_list NestedTensorFromTensorListBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!list_released_, ERR_BACKWARD_TWICE);
  auto list = unpack_list(list_, nullptr);
  IndexRangeGenerator gen;
  auto list_ix = gen.range(list_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ list_ix }),
  };
  return NestedTensorFromTensorListBackward0_apply_functional(std::move(grads), needs_input_grad, list_size_, list);
}

void NestedTensorFromTensorListBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(list_, false);
}
variable_list NestedTensorFromTensorListBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(list_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), NestedTensorFromTensorListBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!list_released_, ERR_BACKWARD_TWICE);
  auto list = unpack_list(list_, nullptr);
  IndexRangeGenerator gen;
  auto list_ix = gen.range(list_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ list_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(list_size_);
  packed_args.pack(list);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(list_);
  return output_result;
#endif
}

static variable_list NestedTensorFromMaskBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<c10::SymInt>& t_sym_sizes)
{
  IndexRangeGenerator gen;
  auto t_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*t*/0]) {
    auto grad_result = any_grad_defined ? (grad.to_padded_tensor_symint(0, t_sym_sizes)) : Tensor();
    copy_range(grad_inputs, t_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list NestedTensorFromMaskBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto t_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return NestedTensorFromMaskBackward0_apply_functional(variable_list(grads), needs_input_grad, t_sym_sizes);
#endif
}

variable_list NestedTensorFromMaskBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto t_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ t_ix }),
  };
  return NestedTensorFromMaskBackward0_apply_functional(std::move(grads), needs_input_grad, t_sym_sizes);
}

void NestedTensorFromMaskBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(t_sym_sizes);
}
variable_list NestedTensorFromMaskBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(t_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), NestedTensorFromMaskBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto t_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ t_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(t_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(t_sym_sizes);
  return output_result;
#endif
}

static variable_list NestedFromPaddedBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, bool& fuse_transform_0213, Tensor& padded)
{
  IndexRangeGenerator gen;
  auto padded_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*padded*/0]) {
    auto grad_result = any_grad_defined ? (_nested_from_padded_backward(grad, padded, fuse_transform_0213)) : Tensor();
    copy_range(grad_inputs, padded_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list NestedFromPaddedBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto fuse_transform_0213 = packed_args.unpack<bool>();
  auto padded = packed_args.unpack<Tensor>();
  return NestedFromPaddedBackward0_apply_functional(variable_list(grads), needs_input_grad, fuse_transform_0213, padded);
#endif
}

variable_list NestedFromPaddedBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto padded = padded_.unpack();
  IndexRangeGenerator gen;
  auto padded_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ padded_ix }),
  };
  return NestedFromPaddedBackward0_apply_functional(std::move(grads), needs_input_grad, fuse_transform_0213, padded);
}

void NestedFromPaddedBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(fuse_transform_0213);
    args.collect(padded_, false);
}
variable_list NestedFromPaddedBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(fuse_transform_0213);
  saved.before(padded_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), NestedFromPaddedBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto padded = padded_.unpack();
  IndexRangeGenerator gen;
  auto padded_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ padded_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(fuse_transform_0213);
  packed_args.pack(padded);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(fuse_transform_0213);
  saved.after(padded_);
  return output_result;
#endif
}

static variable_list ToPaddedTensorBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self, at::Layout& self_layout)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (self_layout == c10::kJagged ? at::_nested_from_padded_tensor_symint(grad, at::_nested_get_offsets(self), at::_nested_get_jagged_dummy(self), at::_nested_get_ragged_idx(self), at::_nested_get_min_seqlen(self).defined() ? std::optional<Tensor>(at::_nested_get_min_seqlen(self)) : ::std::nullopt, at::_nested_get_max_seqlen(self).defined() ? std::optional<Tensor>(at::_nested_get_max_seqlen(self)) : ::std::nullopt, std::optional<c10::SymInt>(at::_nested_get_values(self).sym_size(0))) : at::_nested_from_padded(grad, self._nested_tensor_size())) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ToPaddedTensorBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  auto self_layout = packed_args.unpack<at::Layout>();
  return ToPaddedTensorBackward0_apply_functional(variable_list(grads), needs_input_grad, self, self_layout);
#endif
}

variable_list ToPaddedTensorBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ToPaddedTensorBackward0_apply_functional(std::move(grads), needs_input_grad, self, self_layout);
}

void ToPaddedTensorBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
    args.collect(self_layout);
}
variable_list ToPaddedTensorBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);
  saved.before(self_layout);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Layout>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ToPaddedTensorBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);
  packed_args.pack(self_layout);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  saved.after(self_layout);
  return output_result;
#endif
}

static variable_list NestedFromPaddedTensorBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<c10::SymInt>& padded_sym_sizes)
{
  IndexRangeGenerator gen;
  auto padded_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*padded*/0]) {
    auto grad_result = any_grad_defined ? (grad.to_padded_tensor_symint(0.0, at::OptionalArrayRef<c10::SymInt>(padded_sym_sizes))) : Tensor();
    copy_range(grad_inputs, padded_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list NestedFromPaddedTensorBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto padded_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return NestedFromPaddedTensorBackward0_apply_functional(variable_list(grads), needs_input_grad, padded_sym_sizes);
#endif
}

variable_list NestedFromPaddedTensorBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto padded_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ padded_ix }),
  };
  return NestedFromPaddedTensorBackward0_apply_functional(std::move(grads), needs_input_grad, padded_sym_sizes);
}

void NestedFromPaddedTensorBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(padded_sym_sizes);
}
variable_list NestedFromPaddedTensorBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(padded_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), NestedFromPaddedTensorBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto padded_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ padded_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(padded_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(padded_sym_sizes);
  return output_result;
#endif
}

static variable_list NestedViewFromBufferBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.values()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list NestedViewFromBufferBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return NestedViewFromBufferBackward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list NestedViewFromBufferBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return NestedViewFromBufferBackward0_apply_functional(std::move(grads), needs_input_grad);
}

void NestedViewFromBufferBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list NestedViewFromBufferBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), NestedViewFromBufferBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list NestedViewFromJaggedBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.values()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list NestedViewFromJaggedBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return NestedViewFromJaggedBackward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list NestedViewFromJaggedBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return NestedViewFromJaggedBackward0_apply_functional(std::move(grads), needs_input_grad);
}

void NestedViewFromJaggedBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list NestedViewFromJaggedBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), NestedViewFromJaggedBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list NestedGetValuesBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (_nested_view_from_jagged(grad, at::_nested_get_offsets(self), at::_nested_get_jagged_dummy(self), at::_nested_get_lengths(self), at::_nested_get_ragged_idx(self), at::_nested_get_min_seqlen(self).defined() ? std::optional<Tensor>(at::_nested_get_min_seqlen(self)) : ::std::nullopt, at::_nested_get_max_seqlen(self).defined() ? std::optional<Tensor>(at::_nested_get_max_seqlen(self)) : ::std::nullopt)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list NestedGetValuesBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  return NestedGetValuesBackward0_apply_functional(variable_list(grads), needs_input_grad, self);
#endif
}

variable_list NestedGetValuesBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return NestedGetValuesBackward0_apply_functional(std::move(grads), needs_input_grad, self);
}

void NestedGetValuesBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list NestedGetValuesBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), NestedGetValuesBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list SafeSoftmaxBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim, at::ScalarType& self_scalar_type, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (_softmax_backward_data(grad, result, dim, self_scalar_type)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SafeSoftmaxBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  auto self_scalar_type = packed_args.unpack<at::ScalarType>();
  auto result = packed_args.unpack<Tensor>();
  return SafeSoftmaxBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, self_scalar_type, result);
#endif
}

variable_list SafeSoftmaxBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SafeSoftmaxBackward0_apply_functional(std::move(grads), needs_input_grad, dim, self_scalar_type, result);
}

void SafeSoftmaxBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(self_scalar_type);
    args.collect(result_, true);
}
variable_list SafeSoftmaxBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(self_scalar_type);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::ScalarType>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SafeSoftmaxBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(self_scalar_type);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(self_scalar_type);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list ScaledDotProductEfficientAttentionBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,4> needs_input_grad, Tensor& attn_bias, double& dropout_p, bool& is_causal, Tensor& key, Tensor& query, ::std::optional<double>& scale, Tensor& value, Tensor& log_sumexp, Tensor& output, Tensor& philox_offset, Tensor& philox_seed)
{
  IndexRangeGenerator gen;
  auto query_ix = gen.range(1);
  auto key_ix = gen.range(1);
  auto value_ix = gen.range(1);
  auto attn_bias_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1] || needs_input_grad[2] || needs_input_grad[3]) {
      auto grad_input_mask = std::array<bool, 4>{
        needs_input_grad[0],
        needs_input_grad[1],
        needs_input_grad[2],
        needs_input_grad[3],
      };
    auto grad_result = _scaled_dot_product_efficient_attention_backward(grad, query, key, value, attn_bias, output, log_sumexp, philox_seed, philox_offset, dropout_p, grad_input_mask, is_causal, scale);
      if (needs_input_grad[/*query*/0]) {
        copy_range(grad_inputs, query_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*key*/1]) {
        copy_range(grad_inputs, key_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*value*/2]) {
        copy_range(grad_inputs, value_ix, std::get<2>(grad_result));
      }
      if (needs_input_grad[/*attn_bias*/3]) {
        copy_range(grad_inputs, attn_bias_ix, std::get<3>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list ScaledDotProductEfficientAttentionBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 4>>();
  auto attn_bias = packed_args.unpack<Tensor>();
  auto dropout_p = packed_args.unpack<double>();
  auto is_causal = packed_args.unpack<bool>();
  auto key = packed_args.unpack<Tensor>();
  auto query = packed_args.unpack<Tensor>();
  auto scale = packed_args.unpack<::std::optional<double>>();
  auto value = packed_args.unpack<Tensor>();
  auto log_sumexp = packed_args.unpack<Tensor>();
  auto output = packed_args.unpack<Tensor>();
  auto philox_offset = packed_args.unpack<Tensor>();
  auto philox_seed = packed_args.unpack<Tensor>();
  return ScaledDotProductEfficientAttentionBackward0_apply_functional(variable_list(grads), needs_input_grad, attn_bias, dropout_p, is_causal, key, query, scale, value, log_sumexp, output, philox_offset, philox_seed);
#endif
}

variable_list ScaledDotProductEfficientAttentionBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto attn_bias = attn_bias_.unpack();
  auto key = key_.unpack();
  auto query = query_.unpack();
  auto value = value_.unpack();
  auto log_sumexp = log_sumexp_.unpack(shared_from_this());
  auto output = output_.unpack(shared_from_this());
  auto philox_offset = philox_offset_.unpack(shared_from_this());
  auto philox_seed = philox_seed_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto query_ix = gen.range(1);
  auto key_ix = gen.range(1);
  auto value_ix = gen.range(1);
  auto attn_bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 4>{
    task_should_compute_output({ query_ix }),
    task_should_compute_output({ key_ix }),
    task_should_compute_output({ value_ix }),
    task_should_compute_output({ attn_bias_ix }),
  };
  return ScaledDotProductEfficientAttentionBackward0_apply_functional(std::move(grads), needs_input_grad, attn_bias, dropout_p, is_causal, key, query, scale, value, log_sumexp, output, philox_offset, philox_seed);
}

void ScaledDotProductEfficientAttentionBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(attn_bias_, false);
    args.collect(dropout_p);
    args.collect(is_causal);
    args.collect(key_, false);
    args.collect(query_, false);
    args.collect(scale);
    args.collect(value_, false);
    args.collect(log_sumexp_, true);
    args.collect(output_, true);
    args.collect(philox_offset_, true);
    args.collect(philox_seed_, true);
}
variable_list ScaledDotProductEfficientAttentionBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(attn_bias_);
  saved.before(dropout_p);
  saved.before(is_causal);
  saved.before(key_);
  saved.before(query_);
  saved.before(scale);
  saved.before(value_);
  saved.before(log_sumexp_);
  saved.before(output_);
  saved.before(philox_offset_);
  saved.before(philox_seed_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 4>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<double>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ScaledDotProductEfficientAttentionBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto attn_bias = attn_bias_.unpack();
  auto key = key_.unpack();
  auto query = query_.unpack();
  auto value = value_.unpack();
  auto log_sumexp = log_sumexp_.unpack(shared_from_this());
  auto output = output_.unpack(shared_from_this());
  auto philox_offset = philox_offset_.unpack(shared_from_this());
  auto philox_seed = philox_seed_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto query_ix = gen.range(1);
  auto key_ix = gen.range(1);
  auto value_ix = gen.range(1);
  auto attn_bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 4>{
    task_should_compute_output({ query_ix }),
    task_should_compute_output({ key_ix }),
    task_should_compute_output({ value_ix }),
    task_should_compute_output({ attn_bias_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(attn_bias);
  packed_args.pack(dropout_p);
  packed_args.pack(is_causal);
  packed_args.pack(key);
  packed_args.pack(query);
  packed_args.pack(scale);
  packed_args.pack(value);
  packed_args.pack(log_sumexp);
  packed_args.pack(output);
  packed_args.pack(philox_offset);
  packed_args.pack(philox_seed);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(attn_bias_);
  saved.after(dropout_p);
  saved.after(is_causal);
  saved.after(key_);
  saved.after(query_);
  saved.after(scale);
  saved.after(value_);
  saved.after(log_sumexp_);
  saved.after(output_);
  saved.after(philox_offset_);
  saved.after(philox_seed_);
  return output_result;
#endif
}

static variable_list ScaledDotProductFlashAttentionBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, double& dropout_p, bool& is_causal, Tensor& key, Tensor& query, ::std::optional<double>& scale, Tensor& value, Tensor& cum_seq_k, Tensor& cum_seq_q, Tensor& logsumexp, c10::SymInt& max_k, c10::SymInt& max_q, Tensor& output, Tensor& rng_state, Tensor& unused)
{
  IndexRangeGenerator gen;
  auto query_ix = gen.range(1);
  auto key_ix = gen.range(1);
  auto value_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1] || needs_input_grad[2]) {
  
    auto grad_result = _scaled_dot_product_flash_attention_backward_symint(grad, query, key, value, output, logsumexp, cum_seq_q, cum_seq_k, max_q, max_k, dropout_p, is_causal, rng_state, unused, scale);
      if (needs_input_grad[/*query*/0]) {
        copy_range(grad_inputs, query_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*key*/1]) {
        copy_range(grad_inputs, key_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*value*/2]) {
        copy_range(grad_inputs, value_ix, std::get<2>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list ScaledDotProductFlashAttentionBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto dropout_p = packed_args.unpack<double>();
  auto is_causal = packed_args.unpack<bool>();
  auto key = packed_args.unpack<Tensor>();
  auto query = packed_args.unpack<Tensor>();
  auto scale = packed_args.unpack<::std::optional<double>>();
  auto value = packed_args.unpack<Tensor>();
  auto cum_seq_k = packed_args.unpack<Tensor>();
  auto cum_seq_q = packed_args.unpack<Tensor>();
  auto logsumexp = packed_args.unpack<Tensor>();
  auto max_k = packed_args.unpack<c10::SymInt>();
  auto max_q = packed_args.unpack<c10::SymInt>();
  auto output = packed_args.unpack<Tensor>();
  auto rng_state = packed_args.unpack<Tensor>();
  auto unused = packed_args.unpack<Tensor>();
  return ScaledDotProductFlashAttentionBackward0_apply_functional(variable_list(grads), needs_input_grad, dropout_p, is_causal, key, query, scale, value, cum_seq_k, cum_seq_q, logsumexp, max_k, max_q, output, rng_state, unused);
#endif
}

variable_list ScaledDotProductFlashAttentionBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto key = key_.unpack();
  auto query = query_.unpack();
  auto value = value_.unpack();
  auto cum_seq_k = cum_seq_k_.unpack(shared_from_this());
  auto cum_seq_q = cum_seq_q_.unpack(shared_from_this());
  auto logsumexp = logsumexp_.unpack(shared_from_this());
  auto output = output_.unpack(shared_from_this());
  auto rng_state = rng_state_.unpack(shared_from_this());
  auto unused = unused_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto query_ix = gen.range(1);
  auto key_ix = gen.range(1);
  auto value_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ query_ix }),
    task_should_compute_output({ key_ix }),
    task_should_compute_output({ value_ix }),
  };
  return ScaledDotProductFlashAttentionBackward0_apply_functional(std::move(grads), needs_input_grad, dropout_p, is_causal, key, query, scale, value, cum_seq_k, cum_seq_q, logsumexp, max_k, max_q, output, rng_state, unused);
}

void ScaledDotProductFlashAttentionBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dropout_p);
    args.collect(is_causal);
    args.collect(key_, false);
    args.collect(query_, false);
    args.collect(scale);
    args.collect(value_, false);
    args.collect(cum_seq_k_, true);
    args.collect(cum_seq_q_, true);
    args.collect(logsumexp_, true);
    args.collect(max_k);
    args.collect(max_q);
    args.collect(output_, true);
    args.collect(rng_state_, true);
    args.collect(unused_, true);
}
variable_list ScaledDotProductFlashAttentionBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dropout_p);
  saved.before(is_causal);
  saved.before(key_);
  saved.before(query_);
  saved.before(scale);
  saved.before(value_);
  saved.before(cum_seq_k_);
  saved.before(cum_seq_q_);
  saved.before(logsumexp_);
  saved.before(max_k);
  saved.before(max_q);
  saved.before(output_);
  saved.before(rng_state_);
  saved.before(unused_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<double>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ScaledDotProductFlashAttentionBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto key = key_.unpack();
  auto query = query_.unpack();
  auto value = value_.unpack();
  auto cum_seq_k = cum_seq_k_.unpack(shared_from_this());
  auto cum_seq_q = cum_seq_q_.unpack(shared_from_this());
  auto logsumexp = logsumexp_.unpack(shared_from_this());
  auto output = output_.unpack(shared_from_this());
  auto rng_state = rng_state_.unpack(shared_from_this());
  auto unused = unused_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto query_ix = gen.range(1);
  auto key_ix = gen.range(1);
  auto value_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ query_ix }),
    task_should_compute_output({ key_ix }),
    task_should_compute_output({ value_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dropout_p);
  packed_args.pack(is_causal);
  packed_args.pack(key);
  packed_args.pack(query);
  packed_args.pack(scale);
  packed_args.pack(value);
  packed_args.pack(cum_seq_k);
  packed_args.pack(cum_seq_q);
  packed_args.pack(logsumexp);
  packed_args.pack(max_k);
  packed_args.pack(max_q);
  packed_args.pack(output);
  packed_args.pack(rng_state);
  packed_args.pack(unused);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dropout_p);
  saved.after(is_causal);
  saved.after(key_);
  saved.after(query_);
  saved.after(scale);
  saved.after(value_);
  saved.after(cum_seq_k_);
  saved.after(cum_seq_q_);
  saved.after(logsumexp_);
  saved.after(max_k);
  saved.after(max_q);
  saved.after(output_);
  saved.after(rng_state_);
  saved.after(unused_);
  return output_result;
#endif
}

static variable_list ScaledDotProductFlashAttentionForCpuBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, Tensor& attn_mask, double& dropout_p, bool& is_causal, Tensor& key, Tensor& query, ::std::optional<double>& scale, Tensor& value, Tensor& logsumexp, Tensor& output)
{
  IndexRangeGenerator gen;
  auto query_ix = gen.range(1);
  auto key_ix = gen.range(1);
  auto value_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1] || needs_input_grad[2]) {
  
    auto grad_result = _scaled_dot_product_flash_attention_for_cpu_backward(grad, query, key, value, output, logsumexp, dropout_p, is_causal, attn_mask, scale);
      if (needs_input_grad[/*query*/0]) {
        copy_range(grad_inputs, query_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*key*/1]) {
        copy_range(grad_inputs, key_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*value*/2]) {
        copy_range(grad_inputs, value_ix, std::get<2>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list ScaledDotProductFlashAttentionForCpuBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto attn_mask = packed_args.unpack<Tensor>();
  auto dropout_p = packed_args.unpack<double>();
  auto is_causal = packed_args.unpack<bool>();
  auto key = packed_args.unpack<Tensor>();
  auto query = packed_args.unpack<Tensor>();
  auto scale = packed_args.unpack<::std::optional<double>>();
  auto value = packed_args.unpack<Tensor>();
  auto logsumexp = packed_args.unpack<Tensor>();
  auto output = packed_args.unpack<Tensor>();
  return ScaledDotProductFlashAttentionForCpuBackward0_apply_functional(variable_list(grads), needs_input_grad, attn_mask, dropout_p, is_causal, key, query, scale, value, logsumexp, output);
#endif
}

variable_list ScaledDotProductFlashAttentionForCpuBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto attn_mask = attn_mask_.unpack();
  auto key = key_.unpack();
  auto query = query_.unpack();
  auto value = value_.unpack();
  auto logsumexp = logsumexp_.unpack(shared_from_this());
  auto output = output_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto query_ix = gen.range(1);
  auto key_ix = gen.range(1);
  auto value_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ query_ix }),
    task_should_compute_output({ key_ix }),
    task_should_compute_output({ value_ix }),
  };
  return ScaledDotProductFlashAttentionForCpuBackward0_apply_functional(std::move(grads), needs_input_grad, attn_mask, dropout_p, is_causal, key, query, scale, value, logsumexp, output);
}

void ScaledDotProductFlashAttentionForCpuBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(attn_mask_, false);
    args.collect(dropout_p);
    args.collect(is_causal);
    args.collect(key_, false);
    args.collect(query_, false);
    args.collect(scale);
    args.collect(value_, false);
    args.collect(logsumexp_, true);
    args.collect(output_, true);
}
variable_list ScaledDotProductFlashAttentionForCpuBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(attn_mask_);
  saved.before(dropout_p);
  saved.before(is_causal);
  saved.before(key_);
  saved.before(query_);
  saved.before(scale);
  saved.before(value_);
  saved.before(logsumexp_);
  saved.before(output_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<double>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ScaledDotProductFlashAttentionForCpuBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto attn_mask = attn_mask_.unpack();
  auto key = key_.unpack();
  auto query = query_.unpack();
  auto value = value_.unpack();
  auto logsumexp = logsumexp_.unpack(shared_from_this());
  auto output = output_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto query_ix = gen.range(1);
  auto key_ix = gen.range(1);
  auto value_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ query_ix }),
    task_should_compute_output({ key_ix }),
    task_should_compute_output({ value_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(attn_mask);
  packed_args.pack(dropout_p);
  packed_args.pack(is_causal);
  packed_args.pack(key);
  packed_args.pack(query);
  packed_args.pack(scale);
  packed_args.pack(value);
  packed_args.pack(logsumexp);
  packed_args.pack(output);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(attn_mask_);
  saved.after(dropout_p);
  saved.after(is_causal);
  saved.after(key_);
  saved.after(query_);
  saved.after(scale);
  saved.after(value_);
  saved.after(logsumexp_);
  saved.after(output_);
  return output_result;
#endif
}

static variable_list FlashAttentionBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, Tensor& cum_seq_k, Tensor& cum_seq_q, double& dropout_p, bool& is_causal, Tensor& key, c10::SymInt& max_k, c10::SymInt& max_q, Tensor& query, ::std::optional<double>& scale, Tensor& value, ::std::optional<c10::SymInt>& window_size_left, ::std::optional<c10::SymInt>& window_size_right, Tensor& output, Tensor& rng_state, Tensor& softmax_logsumexp, Tensor& unused)
{
  IndexRangeGenerator gen;
  auto query_ix = gen.range(1);
  auto key_ix = gen.range(1);
  auto value_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1] || needs_input_grad[2]) {
  
    auto grad_result = _flash_attention_backward_symint(grad, query, key, value, output, softmax_logsumexp, cum_seq_q, cum_seq_k, max_q, max_k, dropout_p, is_causal, rng_state, unused, scale, window_size_left, window_size_right);
      if (needs_input_grad[/*query*/0]) {
        copy_range(grad_inputs, query_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*key*/1]) {
        copy_range(grad_inputs, key_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*value*/2]) {
        copy_range(grad_inputs, value_ix, std::get<2>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list FlashAttentionBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto cum_seq_k = packed_args.unpack<Tensor>();
  auto cum_seq_q = packed_args.unpack<Tensor>();
  auto dropout_p = packed_args.unpack<double>();
  auto is_causal = packed_args.unpack<bool>();
  auto key = packed_args.unpack<Tensor>();
  auto max_k = packed_args.unpack<c10::SymInt>();
  auto max_q = packed_args.unpack<c10::SymInt>();
  auto query = packed_args.unpack<Tensor>();
  auto scale = packed_args.unpack<::std::optional<double>>();
  auto value = packed_args.unpack<Tensor>();
  auto window_size_left = packed_args.unpack<::std::optional<c10::SymInt>>();
  auto window_size_right = packed_args.unpack<::std::optional<c10::SymInt>>();
  auto output = packed_args.unpack<Tensor>();
  auto rng_state = packed_args.unpack<Tensor>();
  auto softmax_logsumexp = packed_args.unpack<Tensor>();
  auto unused = packed_args.unpack<Tensor>();
  return FlashAttentionBackward0_apply_functional(variable_list(grads), needs_input_grad, cum_seq_k, cum_seq_q, dropout_p, is_causal, key, max_k, max_q, query, scale, value, window_size_left, window_size_right, output, rng_state, softmax_logsumexp, unused);
#endif
}

variable_list FlashAttentionBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto cum_seq_k = cum_seq_k_.unpack();
  auto cum_seq_q = cum_seq_q_.unpack();
  auto key = key_.unpack();
  auto query = query_.unpack();
  auto value = value_.unpack();
  auto output = output_.unpack(shared_from_this());
  auto rng_state = rng_state_.unpack(shared_from_this());
  auto softmax_logsumexp = softmax_logsumexp_.unpack(shared_from_this());
  auto unused = unused_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto query_ix = gen.range(1);
  auto key_ix = gen.range(1);
  auto value_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ query_ix }),
    task_should_compute_output({ key_ix }),
    task_should_compute_output({ value_ix }),
  };
  return FlashAttentionBackward0_apply_functional(std::move(grads), needs_input_grad, cum_seq_k, cum_seq_q, dropout_p, is_causal, key, max_k, max_q, query, scale, value, window_size_left, window_size_right, output, rng_state, softmax_logsumexp, unused);
}

void FlashAttentionBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(cum_seq_k_, false);
    args.collect(cum_seq_q_, false);
    args.collect(dropout_p);
    args.collect(is_causal);
    args.collect(key_, false);
    args.collect(max_k);
    args.collect(max_q);
    args.collect(query_, false);
    args.collect(scale);
    args.collect(value_, false);
    args.collect(window_size_left);
    args.collect(window_size_right);
    args.collect(output_, true);
    args.collect(rng_state_, true);
    args.collect(softmax_logsumexp_, true);
    args.collect(unused_, true);
}
variable_list FlashAttentionBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(cum_seq_k_);
  saved.before(cum_seq_q_);
  saved.before(dropout_p);
  saved.before(is_causal);
  saved.before(key_);
  saved.before(max_k);
  saved.before(max_q);
  saved.before(query_);
  saved.before(scale);
  saved.before(value_);
  saved.before(window_size_left);
  saved.before(window_size_right);
  saved.before(output_);
  saved.before(rng_state_);
  saved.before(softmax_logsumexp_);
  saved.before(unused_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<double>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), FlashAttentionBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto cum_seq_k = cum_seq_k_.unpack();
  auto cum_seq_q = cum_seq_q_.unpack();
  auto key = key_.unpack();
  auto query = query_.unpack();
  auto value = value_.unpack();
  auto output = output_.unpack(shared_from_this());
  auto rng_state = rng_state_.unpack(shared_from_this());
  auto softmax_logsumexp = softmax_logsumexp_.unpack(shared_from_this());
  auto unused = unused_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto query_ix = gen.range(1);
  auto key_ix = gen.range(1);
  auto value_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ query_ix }),
    task_should_compute_output({ key_ix }),
    task_should_compute_output({ value_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(cum_seq_k);
  packed_args.pack(cum_seq_q);
  packed_args.pack(dropout_p);
  packed_args.pack(is_causal);
  packed_args.pack(key);
  packed_args.pack(max_k);
  packed_args.pack(max_q);
  packed_args.pack(query);
  packed_args.pack(scale);
  packed_args.pack(value);
  packed_args.pack(window_size_left);
  packed_args.pack(window_size_right);
  packed_args.pack(output);
  packed_args.pack(rng_state);
  packed_args.pack(softmax_logsumexp);
  packed_args.pack(unused);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(cum_seq_k_);
  saved.after(cum_seq_q_);
  saved.after(dropout_p);
  saved.after(is_causal);
  saved.after(key_);
  saved.after(max_k);
  saved.after(max_q);
  saved.after(query_);
  saved.after(scale);
  saved.after(value_);
  saved.after(window_size_left);
  saved.after(window_size_right);
  saved.after(output_);
  saved.after(rng_state_);
  saved.after(softmax_logsumexp_);
  saved.after(unused_);
  return output_result;
#endif
}

static variable_list EfficientAttentionBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,4> needs_input_grad, Tensor& bias, Tensor& cu_seqlens_k, Tensor& cu_seqlens_q, int64_t& custom_mask_type, double& dropout_p, Tensor& key, Tensor& query, ::std::optional<double>& scale, Tensor& value, Tensor& logsumexp, c10::SymInt& max_seqlen_batch_k, c10::SymInt& max_seqlen_batch_q, Tensor& output, Tensor& philox_offset, Tensor& philox_seed)
{
  IndexRangeGenerator gen;
  auto query_ix = gen.range(1);
  auto key_ix = gen.range(1);
  auto value_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1] || needs_input_grad[2] || needs_input_grad[3]) {
  
    auto grad_result = _efficient_attention_backward_symint(grad, query, key, value, bias, output, cu_seqlens_q, cu_seqlens_k, max_seqlen_batch_q, max_seqlen_batch_k, logsumexp, dropout_p, philox_seed, philox_offset, custom_mask_type, bias.requires_grad(), scale);
      if (needs_input_grad[/*query*/0]) {
        copy_range(grad_inputs, query_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*key*/1]) {
        copy_range(grad_inputs, key_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*value*/2]) {
        copy_range(grad_inputs, value_ix, std::get<2>(grad_result));
      }
      if (needs_input_grad[/*bias*/3]) {
        copy_range(grad_inputs, bias_ix, std::get<3>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list EfficientAttentionBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 4>>();
  auto bias = packed_args.unpack<Tensor>();
  auto cu_seqlens_k = packed_args.unpack<Tensor>();
  auto cu_seqlens_q = packed_args.unpack<Tensor>();
  auto custom_mask_type = packed_args.unpack<int64_t>();
  auto dropout_p = packed_args.unpack<double>();
  auto key = packed_args.unpack<Tensor>();
  auto query = packed_args.unpack<Tensor>();
  auto scale = packed_args.unpack<::std::optional<double>>();
  auto value = packed_args.unpack<Tensor>();
  auto logsumexp = packed_args.unpack<Tensor>();
  auto max_seqlen_batch_k = packed_args.unpack<c10::SymInt>();
  auto max_seqlen_batch_q = packed_args.unpack<c10::SymInt>();
  auto output = packed_args.unpack<Tensor>();
  auto philox_offset = packed_args.unpack<Tensor>();
  auto philox_seed = packed_args.unpack<Tensor>();
  return EfficientAttentionBackward0_apply_functional(variable_list(grads), needs_input_grad, bias, cu_seqlens_k, cu_seqlens_q, custom_mask_type, dropout_p, key, query, scale, value, logsumexp, max_seqlen_batch_k, max_seqlen_batch_q, output, philox_offset, philox_seed);
#endif
}

variable_list EfficientAttentionBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto bias = bias_.unpack();
  auto cu_seqlens_k = cu_seqlens_k_.unpack();
  auto cu_seqlens_q = cu_seqlens_q_.unpack();
  auto key = key_.unpack();
  auto query = query_.unpack();
  auto value = value_.unpack();
  auto logsumexp = logsumexp_.unpack(shared_from_this());
  auto output = output_.unpack(shared_from_this());
  auto philox_offset = philox_offset_.unpack(shared_from_this());
  auto philox_seed = philox_seed_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto query_ix = gen.range(1);
  auto key_ix = gen.range(1);
  auto value_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 4>{
    task_should_compute_output({ query_ix }),
    task_should_compute_output({ key_ix }),
    task_should_compute_output({ value_ix }),
    task_should_compute_output({ bias_ix }),
  };
  return EfficientAttentionBackward0_apply_functional(std::move(grads), needs_input_grad, bias, cu_seqlens_k, cu_seqlens_q, custom_mask_type, dropout_p, key, query, scale, value, logsumexp, max_seqlen_batch_k, max_seqlen_batch_q, output, philox_offset, philox_seed);
}

void EfficientAttentionBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(bias_, false);
    args.collect(cu_seqlens_k_, false);
    args.collect(cu_seqlens_q_, false);
    args.collect(custom_mask_type);
    args.collect(dropout_p);
    args.collect(key_, false);
    args.collect(query_, false);
    args.collect(scale);
    args.collect(value_, false);
    args.collect(logsumexp_, true);
    args.collect(max_seqlen_batch_k);
    args.collect(max_seqlen_batch_q);
    args.collect(output_, true);
    args.collect(philox_offset_, true);
    args.collect(philox_seed_, true);
}
variable_list EfficientAttentionBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(bias_);
  saved.before(cu_seqlens_k_);
  saved.before(cu_seqlens_q_);
  saved.before(custom_mask_type);
  saved.before(dropout_p);
  saved.before(key_);
  saved.before(query_);
  saved.before(scale);
  saved.before(value_);
  saved.before(logsumexp_);
  saved.before(max_seqlen_batch_k);
  saved.before(max_seqlen_batch_q);
  saved.before(output_);
  saved.before(philox_offset_);
  saved.before(philox_seed_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 4>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<double>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), EfficientAttentionBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto bias = bias_.unpack();
  auto cu_seqlens_k = cu_seqlens_k_.unpack();
  auto cu_seqlens_q = cu_seqlens_q_.unpack();
  auto key = key_.unpack();
  auto query = query_.unpack();
  auto value = value_.unpack();
  auto logsumexp = logsumexp_.unpack(shared_from_this());
  auto output = output_.unpack(shared_from_this());
  auto philox_offset = philox_offset_.unpack(shared_from_this());
  auto philox_seed = philox_seed_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto query_ix = gen.range(1);
  auto key_ix = gen.range(1);
  auto value_ix = gen.range(1);
  auto bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 4>{
    task_should_compute_output({ query_ix }),
    task_should_compute_output({ key_ix }),
    task_should_compute_output({ value_ix }),
    task_should_compute_output({ bias_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(bias);
  packed_args.pack(cu_seqlens_k);
  packed_args.pack(cu_seqlens_q);
  packed_args.pack(custom_mask_type);
  packed_args.pack(dropout_p);
  packed_args.pack(key);
  packed_args.pack(query);
  packed_args.pack(scale);
  packed_args.pack(value);
  packed_args.pack(logsumexp);
  packed_args.pack(max_seqlen_batch_k);
  packed_args.pack(max_seqlen_batch_q);
  packed_args.pack(output);
  packed_args.pack(philox_offset);
  packed_args.pack(philox_seed);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(bias_);
  saved.after(cu_seqlens_k_);
  saved.after(cu_seqlens_q_);
  saved.after(custom_mask_type);
  saved.after(dropout_p);
  saved.after(key_);
  saved.after(query_);
  saved.after(scale);
  saved.after(value_);
  saved.after(logsumexp_);
  saved.after(max_seqlen_batch_k);
  saved.after(max_seqlen_batch_q);
  saved.after(output_);
  saved.after(philox_offset_);
  saved.after(philox_seed_);
  return output_result;
#endif
}

static variable_list ScaledDotProductCudnnAttentionBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, Tensor& attn_bias, double& dropout_p, bool& is_causal, Tensor& key, Tensor& query, ::std::optional<double>& scale, Tensor& value, Tensor& cum_seq_k, Tensor& cum_seq_q, Tensor& logsumexp, c10::SymInt& max_k, c10::SymInt& max_q, Tensor& output, Tensor& philox_offset, Tensor& philox_seed)
{
  IndexRangeGenerator gen;
  auto query_ix = gen.range(1);
  auto key_ix = gen.range(1);
  auto value_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1] || needs_input_grad[2]) {
  
    auto grad_result = _scaled_dot_product_cudnn_attention_backward_symint(grad, query, key, value, output, logsumexp, philox_seed, philox_offset, attn_bias, cum_seq_q, cum_seq_k, max_q, max_k, dropout_p, is_causal, scale);
      if (needs_input_grad[/*query*/0]) {
        copy_range(grad_inputs, query_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*key*/1]) {
        copy_range(grad_inputs, key_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*value*/2]) {
        copy_range(grad_inputs, value_ix, std::get<2>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list ScaledDotProductCudnnAttentionBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto attn_bias = packed_args.unpack<Tensor>();
  auto dropout_p = packed_args.unpack<double>();
  auto is_causal = packed_args.unpack<bool>();
  auto key = packed_args.unpack<Tensor>();
  auto query = packed_args.unpack<Tensor>();
  auto scale = packed_args.unpack<::std::optional<double>>();
  auto value = packed_args.unpack<Tensor>();
  auto cum_seq_k = packed_args.unpack<Tensor>();
  auto cum_seq_q = packed_args.unpack<Tensor>();
  auto logsumexp = packed_args.unpack<Tensor>();
  auto max_k = packed_args.unpack<c10::SymInt>();
  auto max_q = packed_args.unpack<c10::SymInt>();
  auto output = packed_args.unpack<Tensor>();
  auto philox_offset = packed_args.unpack<Tensor>();
  auto philox_seed = packed_args.unpack<Tensor>();
  return ScaledDotProductCudnnAttentionBackward0_apply_functional(variable_list(grads), needs_input_grad, attn_bias, dropout_p, is_causal, key, query, scale, value, cum_seq_k, cum_seq_q, logsumexp, max_k, max_q, output, philox_offset, philox_seed);
#endif
}

variable_list ScaledDotProductCudnnAttentionBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto attn_bias = attn_bias_.unpack();
  auto key = key_.unpack();
  auto query = query_.unpack();
  auto value = value_.unpack();
  auto cum_seq_k = cum_seq_k_.unpack(shared_from_this());
  auto cum_seq_q = cum_seq_q_.unpack(shared_from_this());
  auto logsumexp = logsumexp_.unpack(shared_from_this());
  auto output = output_.unpack(shared_from_this());
  auto philox_offset = philox_offset_.unpack(shared_from_this());
  auto philox_seed = philox_seed_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto query_ix = gen.range(1);
  auto key_ix = gen.range(1);
  auto value_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ query_ix }),
    task_should_compute_output({ key_ix }),
    task_should_compute_output({ value_ix }),
  };
  return ScaledDotProductCudnnAttentionBackward0_apply_functional(std::move(grads), needs_input_grad, attn_bias, dropout_p, is_causal, key, query, scale, value, cum_seq_k, cum_seq_q, logsumexp, max_k, max_q, output, philox_offset, philox_seed);
}

void ScaledDotProductCudnnAttentionBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(attn_bias_, false);
    args.collect(dropout_p);
    args.collect(is_causal);
    args.collect(key_, false);
    args.collect(query_, false);
    args.collect(scale);
    args.collect(value_, false);
    args.collect(cum_seq_k_, true);
    args.collect(cum_seq_q_, true);
    args.collect(logsumexp_, true);
    args.collect(max_k);
    args.collect(max_q);
    args.collect(output_, true);
    args.collect(philox_offset_, true);
    args.collect(philox_seed_, true);
}
variable_list ScaledDotProductCudnnAttentionBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(attn_bias_);
  saved.before(dropout_p);
  saved.before(is_causal);
  saved.before(key_);
  saved.before(query_);
  saved.before(scale);
  saved.before(value_);
  saved.before(cum_seq_k_);
  saved.before(cum_seq_q_);
  saved.before(logsumexp_);
  saved.before(max_k);
  saved.before(max_q);
  saved.before(output_);
  saved.before(philox_offset_);
  saved.before(philox_seed_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<double>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ScaledDotProductCudnnAttentionBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto attn_bias = attn_bias_.unpack();
  auto key = key_.unpack();
  auto query = query_.unpack();
  auto value = value_.unpack();
  auto cum_seq_k = cum_seq_k_.unpack(shared_from_this());
  auto cum_seq_q = cum_seq_q_.unpack(shared_from_this());
  auto logsumexp = logsumexp_.unpack(shared_from_this());
  auto output = output_.unpack(shared_from_this());
  auto philox_offset = philox_offset_.unpack(shared_from_this());
  auto philox_seed = philox_seed_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto query_ix = gen.range(1);
  auto key_ix = gen.range(1);
  auto value_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ query_ix }),
    task_should_compute_output({ key_ix }),
    task_should_compute_output({ value_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(attn_bias);
  packed_args.pack(dropout_p);
  packed_args.pack(is_causal);
  packed_args.pack(key);
  packed_args.pack(query);
  packed_args.pack(scale);
  packed_args.pack(value);
  packed_args.pack(cum_seq_k);
  packed_args.pack(cum_seq_q);
  packed_args.pack(logsumexp);
  packed_args.pack(max_k);
  packed_args.pack(max_q);
  packed_args.pack(output);
  packed_args.pack(philox_offset);
  packed_args.pack(philox_seed);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(attn_bias_);
  saved.after(dropout_p);
  saved.after(is_causal);
  saved.after(key_);
  saved.after(query_);
  saved.after(scale);
  saved.after(value_);
  saved.after(cum_seq_k_);
  saved.after(cum_seq_q_);
  saved.after(logsumexp_);
  saved.after(max_k);
  saved.after(max_q);
  saved.after(output_);
  saved.after(philox_offset_);
  saved.after(philox_seed_);
  return output_result;
#endif
}

static variable_list ScaledDotProductFusedAttentionOverrideableBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,4> needs_input_grad, Tensor& attn_bias, double& dropout_p, bool& is_causal, Tensor& key, Tensor& query, ::std::optional<double>& scale, Tensor& value, Tensor& cum_seq_k, Tensor& cum_seq_q, Tensor& logsumexp, c10::SymInt& max_k, c10::SymInt& max_q, Tensor& output, Tensor& philox_offset, Tensor& philox_seed)
{
  IndexRangeGenerator gen;
  auto query_ix = gen.range(1);
  auto key_ix = gen.range(1);
  auto value_ix = gen.range(1);
  auto attn_bias_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1] || needs_input_grad[2] || needs_input_grad[3]) {
      auto grad_input_mask = std::array<bool, 4>{
        needs_input_grad[0],
        needs_input_grad[1],
        needs_input_grad[2],
        needs_input_grad[3],
      };
    auto grad_result = _scaled_dot_product_fused_attention_overrideable_backward_symint(grad, query, key, value, attn_bias, grad_input_mask, output, logsumexp, cum_seq_q, cum_seq_k, max_q, max_k, dropout_p, is_causal, philox_seed, philox_offset, scale);
      if (needs_input_grad[/*query*/0]) {
        copy_range(grad_inputs, query_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*key*/1]) {
        copy_range(grad_inputs, key_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*value*/2]) {
        copy_range(grad_inputs, value_ix, std::get<2>(grad_result));
      }
      if (needs_input_grad[/*attn_bias*/3]) {
        copy_range(grad_inputs, attn_bias_ix, std::get<3>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list ScaledDotProductFusedAttentionOverrideableBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 4>>();
  auto attn_bias = packed_args.unpack<Tensor>();
  auto dropout_p = packed_args.unpack<double>();
  auto is_causal = packed_args.unpack<bool>();
  auto key = packed_args.unpack<Tensor>();
  auto query = packed_args.unpack<Tensor>();
  auto scale = packed_args.unpack<::std::optional<double>>();
  auto value = packed_args.unpack<Tensor>();
  auto cum_seq_k = packed_args.unpack<Tensor>();
  auto cum_seq_q = packed_args.unpack<Tensor>();
  auto logsumexp = packed_args.unpack<Tensor>();
  auto max_k = packed_args.unpack<c10::SymInt>();
  auto max_q = packed_args.unpack<c10::SymInt>();
  auto output = packed_args.unpack<Tensor>();
  auto philox_offset = packed_args.unpack<Tensor>();
  auto philox_seed = packed_args.unpack<Tensor>();
  return ScaledDotProductFusedAttentionOverrideableBackward0_apply_functional(variable_list(grads), needs_input_grad, attn_bias, dropout_p, is_causal, key, query, scale, value, cum_seq_k, cum_seq_q, logsumexp, max_k, max_q, output, philox_offset, philox_seed);
#endif
}

variable_list ScaledDotProductFusedAttentionOverrideableBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto attn_bias = attn_bias_.unpack();
  auto key = key_.unpack();
  auto query = query_.unpack();
  auto value = value_.unpack();
  auto cum_seq_k = cum_seq_k_.unpack(shared_from_this());
  auto cum_seq_q = cum_seq_q_.unpack(shared_from_this());
  auto logsumexp = logsumexp_.unpack(shared_from_this());
  auto output = output_.unpack(shared_from_this());
  auto philox_offset = philox_offset_.unpack(shared_from_this());
  auto philox_seed = philox_seed_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto query_ix = gen.range(1);
  auto key_ix = gen.range(1);
  auto value_ix = gen.range(1);
  auto attn_bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 4>{
    task_should_compute_output({ query_ix }),
    task_should_compute_output({ key_ix }),
    task_should_compute_output({ value_ix }),
    task_should_compute_output({ attn_bias_ix }),
  };
  return ScaledDotProductFusedAttentionOverrideableBackward0_apply_functional(std::move(grads), needs_input_grad, attn_bias, dropout_p, is_causal, key, query, scale, value, cum_seq_k, cum_seq_q, logsumexp, max_k, max_q, output, philox_offset, philox_seed);
}

void ScaledDotProductFusedAttentionOverrideableBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(attn_bias_, false);
    args.collect(dropout_p);
    args.collect(is_causal);
    args.collect(key_, false);
    args.collect(query_, false);
    args.collect(scale);
    args.collect(value_, false);
    args.collect(cum_seq_k_, true);
    args.collect(cum_seq_q_, true);
    args.collect(logsumexp_, true);
    args.collect(max_k);
    args.collect(max_q);
    args.collect(output_, true);
    args.collect(philox_offset_, true);
    args.collect(philox_seed_, true);
}
variable_list ScaledDotProductFusedAttentionOverrideableBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(attn_bias_);
  saved.before(dropout_p);
  saved.before(is_causal);
  saved.before(key_);
  saved.before(query_);
  saved.before(scale);
  saved.before(value_);
  saved.before(cum_seq_k_);
  saved.before(cum_seq_q_);
  saved.before(logsumexp_);
  saved.before(max_k);
  saved.before(max_q);
  saved.before(output_);
  saved.before(philox_offset_);
  saved.before(philox_seed_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 4>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<double>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<double>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ScaledDotProductFusedAttentionOverrideableBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto attn_bias = attn_bias_.unpack();
  auto key = key_.unpack();
  auto query = query_.unpack();
  auto value = value_.unpack();
  auto cum_seq_k = cum_seq_k_.unpack(shared_from_this());
  auto cum_seq_q = cum_seq_q_.unpack(shared_from_this());
  auto logsumexp = logsumexp_.unpack(shared_from_this());
  auto output = output_.unpack(shared_from_this());
  auto philox_offset = philox_offset_.unpack(shared_from_this());
  auto philox_seed = philox_seed_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto query_ix = gen.range(1);
  auto key_ix = gen.range(1);
  auto value_ix = gen.range(1);
  auto attn_bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 4>{
    task_should_compute_output({ query_ix }),
    task_should_compute_output({ key_ix }),
    task_should_compute_output({ value_ix }),
    task_should_compute_output({ attn_bias_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(attn_bias);
  packed_args.pack(dropout_p);
  packed_args.pack(is_causal);
  packed_args.pack(key);
  packed_args.pack(query);
  packed_args.pack(scale);
  packed_args.pack(value);
  packed_args.pack(cum_seq_k);
  packed_args.pack(cum_seq_q);
  packed_args.pack(logsumexp);
  packed_args.pack(max_k);
  packed_args.pack(max_q);
  packed_args.pack(output);
  packed_args.pack(philox_offset);
  packed_args.pack(philox_seed);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(attn_bias_);
  saved.after(dropout_p);
  saved.after(is_causal);
  saved.after(key_);
  saved.after(query_);
  saved.after(scale);
  saved.after(value_);
  saved.after(cum_seq_k_);
  saved.after(cum_seq_q_);
  saved.after(logsumexp_);
  saved.after(max_k);
  saved.after(max_q);
  saved.after(output_);
  saved.after(philox_offset_);
  saved.after(philox_seed_);
  return output_result;
#endif
}

static variable_list FftR2CBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<int64_t>& dim, int64_t& normalization, bool& onesided, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (fft_r2c_backward(grad, dim, normalization, onesided, self.sym_size(dim.back()))) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list FftR2CBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<std::vector<int64_t>>();
  auto normalization = packed_args.unpack<int64_t>();
  auto onesided = packed_args.unpack<bool>();
  auto self = packed_args.unpack<Tensor>();
  return FftR2CBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, normalization, onesided, self);
#endif
}

variable_list FftR2CBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return FftR2CBackward0_apply_functional(std::move(grads), needs_input_grad, dim, normalization, onesided, self);
}

void FftR2CBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(normalization);
    args.collect(onesided);
    args.collect(self_, false);
}
variable_list FftR2CBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(normalization);
  saved.before(onesided);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), FftR2CBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(normalization);
  packed_args.pack(onesided);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(normalization);
  saved.after(onesided);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list FftC2RBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<int64_t>& dim, int64_t& normalization)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (fft_c2r_backward(grad, dim, normalization)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list FftC2RBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<std::vector<int64_t>>();
  auto normalization = packed_args.unpack<int64_t>();
  return FftC2RBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, normalization);
#endif
}

variable_list FftC2RBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return FftC2RBackward0_apply_functional(std::move(grads), needs_input_grad, dim, normalization);
}

void FftC2RBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(normalization);
}
variable_list FftC2RBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(normalization);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), FftC2RBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(normalization);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(normalization);
  return output_result;
#endif
}

static variable_list FftC2CBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<c10::SymInt>& dim, bool& forward, int64_t& normalization)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (_fft_c2c_symint(grad, dim, normalization, !forward)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list FftC2CBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<std::vector<c10::SymInt>>();
  auto forward = packed_args.unpack<bool>();
  auto normalization = packed_args.unpack<int64_t>();
  return FftC2CBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, forward, normalization);
#endif
}

variable_list FftC2CBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return FftC2CBackward0_apply_functional(std::move(grads), needs_input_grad, dim, forward, normalization);
}

void FftC2CBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(forward);
    args.collect(normalization);
}
variable_list FftC2CBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(forward);
  saved.before(normalization);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), FftC2CBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(forward);
  packed_args.pack(normalization);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(forward);
  saved.after(normalization);
  return output_result;
#endif
}

static variable_list UnbindBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (unbind_backward(grads, dim)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list UnbindBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  return UnbindBackward0_apply_functional(variable_list(grads), needs_input_grad, dim);
#endif
}

variable_list UnbindBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return UnbindBackward0_apply_functional(std::move(grads), needs_input_grad, dim);
}

void UnbindBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
}
variable_list UnbindBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), UnbindBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  return output_result;
#endif
}

static variable_list UnbindBackwardAutogradNestedTensor0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim, Tensor& self, at::Layout& self_layout, at::TensorOptions& self_options)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (self_layout == c10::kJagged ? unbind_backward_nested_jagged(grads, self, dim) : unbind_backward_nested(grads, at::native::get_nested_tensor_impl(self)->get_nested_sizes(), dim, self_options)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list UnbindBackwardAutogradNestedTensor0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  auto self = packed_args.unpack<Tensor>();
  auto self_layout = packed_args.unpack<at::Layout>();
  auto self_options = packed_args.unpack<at::TensorOptions>();
  return UnbindBackwardAutogradNestedTensor0_apply_functional(variable_list(grads), needs_input_grad, dim, self, self_layout, self_options);
#endif
}

variable_list UnbindBackwardAutogradNestedTensor0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return UnbindBackwardAutogradNestedTensor0_apply_functional(std::move(grads), needs_input_grad, dim, self, self_layout, self_options);
}

void UnbindBackwardAutogradNestedTensor0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(self_, false);
    args.collect(self_layout);
    args.collect(self_options);
}
variable_list UnbindBackwardAutogradNestedTensor0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(self_);
  saved.before(self_layout);
  saved.before(self_options);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Layout>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::TensorOptions>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), UnbindBackwardAutogradNestedTensor0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(self);
  packed_args.pack(self_layout);
  packed_args.pack(self_options);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(self_);
  saved.after(self_layout);
  saved.after(self_options);
  return output_result;
#endif
}

static variable_list StackBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t tensors_size_, int64_t& dim, ::std::vector<at::ScalarType>& tensors_args_scalartypes)
{
  IndexRangeGenerator gen;
  auto tensors_ix = gen.range(tensors_size_);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[/*tensors*/0]) {
    auto grad_result = stack_tensors_backward(grad, dim, tensors_args_scalartypes);
    copy_range(grad_inputs, tensors_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list StackBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto tensors_size_ = packed_args.unpack<size_t>();
  auto dim = packed_args.unpack<int64_t>();
  auto tensors_args_scalartypes = packed_args.unpack<::std::vector<at::ScalarType>>();
  return StackBackward0_apply_functional(variable_list(grads), needs_input_grad, tensors_size_, dim, tensors_args_scalartypes);
#endif
}

variable_list StackBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto tensors_ix = gen.range(tensors_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ tensors_ix }),
  };
  return StackBackward0_apply_functional(std::move(grads), needs_input_grad, tensors_size_, dim, tensors_args_scalartypes);
}

void StackBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(tensors_args_scalartypes);
}
variable_list StackBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(tensors_args_scalartypes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::vector<at::ScalarType>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), StackBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto tensors_ix = gen.range(tensors_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ tensors_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(tensors_size_);
  packed_args.pack(dim);
  packed_args.pack(tensors_args_scalartypes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(tensors_args_scalartypes);
  return output_result;
#endif
}

static variable_list ThnnFusedLstmCellBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,5> needs_input_grad, Tensor& cx, Tensor& hidden_bias, Tensor& hidden_gates, Tensor& input_bias, Tensor& input_gates, Tensor& result1, Tensor& result2)
{
  IndexRangeGenerator gen;
  auto input_gates_ix = gen.range(1);
  auto hidden_gates_ix = gen.range(1);
  auto cx_ix = gen.range(1);
  auto input_bias_ix = gen.range(1);
  auto hidden_bias_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[0] || needs_input_grad[1] || needs_input_grad[2] || needs_input_grad[3] || needs_input_grad[4]) {
  
    auto grad_result = GradMode::is_enabled() ? _thnn_differentiable_lstm_cell_backward(grads[0], grads[1], input_gates, hidden_gates, input_bias, hidden_bias, cx, result1) : _thnn_fused_lstm_cell_backward(grads[0], grads[1], cx, result1, result2, input_bias.defined());
      if (needs_input_grad[/*input_gates*/0]) {
        copy_range(grad_inputs, input_gates_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*hidden_gates*/1]) {
        copy_range(grad_inputs, hidden_gates_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*cx*/2]) {
        copy_range(grad_inputs, cx_ix, std::get<2>(grad_result));
      }
      if (needs_input_grad[/*input_bias*/3]) {
        copy_range(grad_inputs, input_bias_ix, std::get<3>(grad_result));
      }
      if (needs_input_grad[/*hidden_bias*/4]) {
        copy_range(grad_inputs, hidden_bias_ix, std::get<4>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list ThnnFusedLstmCellBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 5>>();
  auto cx = packed_args.unpack<Tensor>();
  auto hidden_bias = packed_args.unpack<Tensor>();
  auto hidden_gates = packed_args.unpack<Tensor>();
  auto input_bias = packed_args.unpack<Tensor>();
  auto input_gates = packed_args.unpack<Tensor>();
  auto result1 = packed_args.unpack<Tensor>();
  auto result2 = packed_args.unpack<Tensor>();
  return ThnnFusedLstmCellBackward0_apply_functional(variable_list(grads), needs_input_grad, cx, hidden_bias, hidden_gates, input_bias, input_gates, result1, result2);
#endif
}

variable_list ThnnFusedLstmCellBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto cx = cx_.unpack();
  auto hidden_bias = hidden_bias_.unpack();
  auto hidden_gates = hidden_gates_.unpack();
  auto input_bias = input_bias_.unpack();
  auto input_gates = input_gates_.unpack();
  auto result1 = result1_.unpack(shared_from_this());
  auto result2 = result2_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto input_gates_ix = gen.range(1);
  auto hidden_gates_ix = gen.range(1);
  auto cx_ix = gen.range(1);
  auto input_bias_ix = gen.range(1);
  auto hidden_bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 5>{
    task_should_compute_output({ input_gates_ix }),
    task_should_compute_output({ hidden_gates_ix }),
    task_should_compute_output({ cx_ix }),
    task_should_compute_output({ input_bias_ix }),
    task_should_compute_output({ hidden_bias_ix }),
  };
  return ThnnFusedLstmCellBackward0_apply_functional(std::move(grads), needs_input_grad, cx, hidden_bias, hidden_gates, input_bias, input_gates, result1, result2);
}

void ThnnFusedLstmCellBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(cx_, false);
    args.collect(hidden_bias_, false);
    args.collect(hidden_gates_, false);
    args.collect(input_bias_, false);
    args.collect(input_gates_, false);
    args.collect(result1_, true);
    args.collect(result2_, true);
}
variable_list ThnnFusedLstmCellBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(cx_);
  saved.before(hidden_bias_);
  saved.before(hidden_gates_);
  saved.before(input_bias_);
  saved.before(input_gates_);
  saved.before(result1_);
  saved.before(result2_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 5>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ThnnFusedLstmCellBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto cx = cx_.unpack();
  auto hidden_bias = hidden_bias_.unpack();
  auto hidden_gates = hidden_gates_.unpack();
  auto input_bias = input_bias_.unpack();
  auto input_gates = input_gates_.unpack();
  auto result1 = result1_.unpack(shared_from_this());
  auto result2 = result2_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto input_gates_ix = gen.range(1);
  auto hidden_gates_ix = gen.range(1);
  auto cx_ix = gen.range(1);
  auto input_bias_ix = gen.range(1);
  auto hidden_bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 5>{
    task_should_compute_output({ input_gates_ix }),
    task_should_compute_output({ hidden_gates_ix }),
    task_should_compute_output({ cx_ix }),
    task_should_compute_output({ input_bias_ix }),
    task_should_compute_output({ hidden_bias_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(cx);
  packed_args.pack(hidden_bias);
  packed_args.pack(hidden_gates);
  packed_args.pack(input_bias);
  packed_args.pack(input_gates);
  packed_args.pack(result1);
  packed_args.pack(result2);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(cx_);
  saved.after(hidden_bias_);
  saved.after(hidden_gates_);
  saved.after(input_bias_);
  saved.after(input_gates_);
  saved.after(result1_);
  saved.after(result2_);
  return output_result;
#endif
}

static variable_list ThnnFusedGruCellBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,5> needs_input_grad, Tensor& hidden_bias, Tensor& hidden_gates, Tensor& hx, Tensor& input_bias, Tensor& input_gates, Tensor& result1)
{
  IndexRangeGenerator gen;
  auto input_gates_ix = gen.range(1);
  auto hidden_gates_ix = gen.range(1);
  auto hx_ix = gen.range(1);
  auto input_bias_ix = gen.range(1);
  auto hidden_bias_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1] || needs_input_grad[2] || needs_input_grad[3] || needs_input_grad[4]) {
  
    auto grad_result = grad.defined() ? (GradMode::is_enabled() ? _thnn_differentiable_gru_cell_backward(grad, input_gates, hidden_gates, hx, input_bias, hidden_bias) : _thnn_fused_gru_cell_backward(grad, result1, input_bias.defined())) : std::tuple<Tensor, Tensor, Tensor, Tensor, Tensor>();
      if (needs_input_grad[/*input_gates*/0]) {
        copy_range(grad_inputs, input_gates_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*hidden_gates*/1]) {
        copy_range(grad_inputs, hidden_gates_ix, std::get<1>(grad_result));
      }
      if (needs_input_grad[/*hx*/2]) {
        copy_range(grad_inputs, hx_ix, std::get<2>(grad_result));
      }
      if (needs_input_grad[/*input_bias*/3]) {
        copy_range(grad_inputs, input_bias_ix, std::get<3>(grad_result));
      }
      if (needs_input_grad[/*hidden_bias*/4]) {
        copy_range(grad_inputs, hidden_bias_ix, std::get<4>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list ThnnFusedGruCellBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 5>>();
  auto hidden_bias = packed_args.unpack<Tensor>();
  auto hidden_gates = packed_args.unpack<Tensor>();
  auto hx = packed_args.unpack<Tensor>();
  auto input_bias = packed_args.unpack<Tensor>();
  auto input_gates = packed_args.unpack<Tensor>();
  auto result1 = packed_args.unpack<Tensor>();
  return ThnnFusedGruCellBackward0_apply_functional(variable_list(grads), needs_input_grad, hidden_bias, hidden_gates, hx, input_bias, input_gates, result1);
#endif
}

variable_list ThnnFusedGruCellBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto hidden_bias = hidden_bias_.unpack();
  auto hidden_gates = hidden_gates_.unpack();
  auto hx = hx_.unpack();
  auto input_bias = input_bias_.unpack();
  auto input_gates = input_gates_.unpack();
  auto result1 = result1_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto input_gates_ix = gen.range(1);
  auto hidden_gates_ix = gen.range(1);
  auto hx_ix = gen.range(1);
  auto input_bias_ix = gen.range(1);
  auto hidden_bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 5>{
    task_should_compute_output({ input_gates_ix }),
    task_should_compute_output({ hidden_gates_ix }),
    task_should_compute_output({ hx_ix }),
    task_should_compute_output({ input_bias_ix }),
    task_should_compute_output({ hidden_bias_ix }),
  };
  return ThnnFusedGruCellBackward0_apply_functional(std::move(grads), needs_input_grad, hidden_bias, hidden_gates, hx, input_bias, input_gates, result1);
}

void ThnnFusedGruCellBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(hidden_bias_, false);
    args.collect(hidden_gates_, false);
    args.collect(hx_, false);
    args.collect(input_bias_, false);
    args.collect(input_gates_, false);
    args.collect(result1_, true);
}
variable_list ThnnFusedGruCellBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(hidden_bias_);
  saved.before(hidden_gates_);
  saved.before(hx_);
  saved.before(input_bias_);
  saved.before(input_gates_);
  saved.before(result1_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 5>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ThnnFusedGruCellBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto hidden_bias = hidden_bias_.unpack();
  auto hidden_gates = hidden_gates_.unpack();
  auto hx = hx_.unpack();
  auto input_bias = input_bias_.unpack();
  auto input_gates = input_gates_.unpack();
  auto result1 = result1_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto input_gates_ix = gen.range(1);
  auto hidden_gates_ix = gen.range(1);
  auto hx_ix = gen.range(1);
  auto input_bias_ix = gen.range(1);
  auto hidden_bias_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 5>{
    task_should_compute_output({ input_gates_ix }),
    task_should_compute_output({ hidden_gates_ix }),
    task_should_compute_output({ hx_ix }),
    task_should_compute_output({ input_bias_ix }),
    task_should_compute_output({ hidden_bias_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(hidden_bias);
  packed_args.pack(hidden_gates);
  packed_args.pack(hx);
  packed_args.pack(input_bias);
  packed_args.pack(input_gates);
  packed_args.pack(result1);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(hidden_bias_);
  saved.after(hidden_gates_);
  saved.after(hx_);
  saved.after(input_bias_);
  saved.after(input_gates_);
  saved.after(result1_);
  return output_result;
#endif
}

static variable_list PackPaddedSequenceBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, bool& batch_first, std::vector<c10::SymInt>& input_sym_sizes, Tensor& result1)
{
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*input*/0]) {
    auto grad_result = any_grad_defined ? (_pack_padded_sequence_backward_symint(grad, input_sym_sizes, result1, batch_first)) : Tensor();
    copy_range(grad_inputs, input_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list PackPaddedSequenceBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto batch_first = packed_args.unpack<bool>();
  auto input_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  auto result1 = packed_args.unpack<Tensor>();
  return PackPaddedSequenceBackward0_apply_functional(variable_list(grads), needs_input_grad, batch_first, input_sym_sizes, result1);
#endif
}

variable_list PackPaddedSequenceBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto result1 = result1_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ input_ix }),
  };
  return PackPaddedSequenceBackward0_apply_functional(std::move(grads), needs_input_grad, batch_first, input_sym_sizes, result1);
}

void PackPaddedSequenceBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(batch_first);
    args.collect(input_sym_sizes);
    args.collect(result1_, true);
}
variable_list PackPaddedSequenceBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(batch_first);
  saved.before(input_sym_sizes);
  saved.before(result1_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), PackPaddedSequenceBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto result1 = result1_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto input_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ input_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(batch_first);
  packed_args.pack(input_sym_sizes);
  packed_args.pack(result1);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(batch_first);
  saved.after(input_sym_sizes);
  saved.after(result1_);
  return output_result;
#endif
}

static variable_list SegmentReduceBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& axis, Tensor& data, ::std::optional<at::Scalar>& initial, Tensor& lengths, Tensor& offsets, std::string& reduce, Tensor& result)
{
  IndexRangeGenerator gen;
  auto data_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*data*/0]) {
    auto grad_result = any_grad_defined ? (_segment_reduce_backward(grad, result, data, reduce, lengths, offsets, axis, initial)) : Tensor();
    copy_range(grad_inputs, data_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SegmentReduceBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto axis = packed_args.unpack<int64_t>();
  auto data = packed_args.unpack<Tensor>();
  auto initial = packed_args.unpack<::std::optional<at::Scalar>>();
  auto lengths = packed_args.unpack<Tensor>();
  auto offsets = packed_args.unpack<Tensor>();
  auto reduce = packed_args.unpack<std::string>();
  auto result = packed_args.unpack<Tensor>();
  return SegmentReduceBackward0_apply_functional(variable_list(grads), needs_input_grad, axis, data, initial, lengths, offsets, reduce, result);
#endif
}

variable_list SegmentReduceBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto data = data_.unpack();
  auto lengths = lengths_.unpack();
  auto offsets = offsets_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto data_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ data_ix }),
  };
  return SegmentReduceBackward0_apply_functional(std::move(grads), needs_input_grad, axis, data, initial, lengths, offsets, reduce, result);
}

void SegmentReduceBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(axis);
    args.collect(data_, false);
    args.collect(initial);
    args.collect(lengths_, false);
    args.collect(offsets_, false);
    args.collect(reduce);
    args.collect(result_, true);
}
variable_list SegmentReduceBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(axis);
  saved.before(data_);
  saved.before(initial);
  saved.before(lengths_);
  saved.before(offsets_);
  saved.before(reduce);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<at::Scalar>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::string>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SegmentReduceBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto data = data_.unpack();
  auto lengths = lengths_.unpack();
  auto offsets = offsets_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto data_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ data_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(axis);
  packed_args.pack(data);
  packed_args.pack(initial);
  packed_args.pack(lengths);
  packed_args.pack(offsets);
  packed_args.pack(reduce);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(axis);
  saved.after(data_);
  saved.after(initial);
  saved.after(lengths_);
  saved.after(offsets_);
  saved.after(reduce);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list PinMemoryBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list PinMemoryBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return PinMemoryBackward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list PinMemoryBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return PinMemoryBackward0_apply_functional(std::move(grads), needs_input_grad);
}

void PinMemoryBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list PinMemoryBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), PinMemoryBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list TestWarnInAutogradBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (warn_backwards(grad)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list TestWarnInAutogradBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return TestWarnInAutogradBackward0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list TestWarnInAutogradBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return TestWarnInAutogradBackward0_apply_functional(std::move(grads), needs_input_grad);
}

void TestWarnInAutogradBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list TestWarnInAutogradBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), TestWarnInAutogradBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list TestAutogradMultipleDispatchBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<c10::SymInt>& self_sym_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.expand_symint(self_sym_sizes) + 1) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list TestAutogradMultipleDispatchBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return TestAutogradMultipleDispatchBackward0_apply_functional(variable_list(grads), needs_input_grad, self_sym_sizes);
#endif
}

variable_list TestAutogradMultipleDispatchBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return TestAutogradMultipleDispatchBackward0_apply_functional(std::move(grads), needs_input_grad, self_sym_sizes);
}

void TestAutogradMultipleDispatchBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_sym_sizes);
}
variable_list TestAutogradMultipleDispatchBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), TestAutogradMultipleDispatchBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_sym_sizes);
  return output_result;
#endif
}

static variable_list TestAutogradMultipleDispatchBackwardAutogradNestedTensor0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.mul(grad)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list TestAutogradMultipleDispatchBackwardAutogradNestedTensor0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return TestAutogradMultipleDispatchBackwardAutogradNestedTensor0_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list TestAutogradMultipleDispatchBackwardAutogradNestedTensor0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return TestAutogradMultipleDispatchBackwardAutogradNestedTensor0_apply_functional(std::move(grads), needs_input_grad);
}

void TestAutogradMultipleDispatchBackwardAutogradNestedTensor0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list TestAutogradMultipleDispatchBackwardAutogradNestedTensor0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), TestAutogradMultipleDispatchBackwardAutogradNestedTensor0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list TestAutogradMultipleDispatchBackwardAutogradCUDA0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<c10::SymInt>& self_sym_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.expand_symint(self_sym_sizes) * 2) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list TestAutogradMultipleDispatchBackwardAutogradCUDA0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return TestAutogradMultipleDispatchBackwardAutogradCUDA0_apply_functional(variable_list(grads), needs_input_grad, self_sym_sizes);
#endif
}

variable_list TestAutogradMultipleDispatchBackwardAutogradCUDA0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return TestAutogradMultipleDispatchBackwardAutogradCUDA0_apply_functional(std::move(grads), needs_input_grad, self_sym_sizes);
}

void TestAutogradMultipleDispatchBackwardAutogradCUDA0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_sym_sizes);
}
variable_list TestAutogradMultipleDispatchBackwardAutogradCUDA0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), TestAutogradMultipleDispatchBackwardAutogradCUDA0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_sym_sizes);
  return output_result;
#endif
}

static variable_list TestAutogradMultipleDispatchBackwardAutogradNestedTensor1_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.mul(grad).add(grad)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list TestAutogradMultipleDispatchBackwardAutogradNestedTensor1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return TestAutogradMultipleDispatchBackwardAutogradNestedTensor1_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list TestAutogradMultipleDispatchBackwardAutogradNestedTensor1::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return TestAutogradMultipleDispatchBackwardAutogradNestedTensor1_apply_functional(std::move(grads), needs_input_grad);
}

void TestAutogradMultipleDispatchBackwardAutogradNestedTensor1::compiled_args(CompiledNodeArgs& args) const {

}
variable_list TestAutogradMultipleDispatchBackwardAutogradNestedTensor1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), TestAutogradMultipleDispatchBackwardAutogradNestedTensor1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list TestAutogradMultipleDispatchViewBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.reshape_as(self)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list TestAutogradMultipleDispatchViewBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  return TestAutogradMultipleDispatchViewBackward0_apply_functional(variable_list(grads), needs_input_grad, self);
#endif
}

variable_list TestAutogradMultipleDispatchViewBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return TestAutogradMultipleDispatchViewBackward0_apply_functional(std::move(grads), needs_input_grad, self);
}

void TestAutogradMultipleDispatchViewBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list TestAutogradMultipleDispatchViewBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), TestAutogradMultipleDispatchViewBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list TestAutogradMultipleDispatchViewBackwardAutogradCUDA0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.reshape_as(self) + 1) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list TestAutogradMultipleDispatchViewBackwardAutogradCUDA0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  return TestAutogradMultipleDispatchViewBackwardAutogradCUDA0_apply_functional(variable_list(grads), needs_input_grad, self);
#endif
}

variable_list TestAutogradMultipleDispatchViewBackwardAutogradCUDA0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return TestAutogradMultipleDispatchViewBackwardAutogradCUDA0_apply_functional(std::move(grads), needs_input_grad, self);
}

void TestAutogradMultipleDispatchViewBackwardAutogradCUDA0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list TestAutogradMultipleDispatchViewBackwardAutogradCUDA0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), TestAutogradMultipleDispatchViewBackwardAutogradCUDA0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list ScatterReduceBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, int64_t& dim, bool& include_self, Tensor& index, std::string& reduce, Tensor& self, Tensor& src, Tensor& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto src_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  if (needs_input_grad[0] || needs_input_grad[1]) {
  
    auto grad_result = scatter_reduce_backward(grad, self, dim, index, src, reduce, include_self, result);
      if (needs_input_grad[/*self*/0]) {
        copy_range(grad_inputs, self_ix, std::get<0>(grad_result));
      }
      if (needs_input_grad[/*src*/1]) {
        copy_range(grad_inputs, src_ix, std::get<1>(grad_result));
      }
  }
  return grad_inputs;
}
inline variable_list ScatterReduceBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto dim = packed_args.unpack<int64_t>();
  auto include_self = packed_args.unpack<bool>();
  auto index = packed_args.unpack<Tensor>();
  auto reduce = packed_args.unpack<std::string>();
  auto self = packed_args.unpack<Tensor>();
  auto src = packed_args.unpack<Tensor>();
  auto result = packed_args.unpack<Tensor>();
  return ScatterReduceBackward0_apply_functional(variable_list(grads), needs_input_grad, dim, include_self, index, reduce, self, src, result);
#endif
}

variable_list ScatterReduceBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto index = index_.unpack();
  auto self = self_.unpack();
  auto src = src_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto src_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ src_ix }),
  };
  return ScatterReduceBackward0_apply_functional(std::move(grads), needs_input_grad, dim, include_self, index, reduce, self, src, result);
}

void ScatterReduceBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(include_self);
    args.collect(index_, false);
    args.collect(reduce);
    args.collect(self_, false);
    args.collect(src_, false);
    args.collect(result_, true);
}
variable_list ScatterReduceBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(include_self);
  saved.before(index_);
  saved.before(reduce);
  saved.before(self_);
  saved.before(src_);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<bool>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::string>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ScatterReduceBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto index = index_.unpack();
  auto self = self_.unpack();
  auto src = src_.unpack();
  auto result = result_.unpack(shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto src_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ src_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(include_self);
  packed_args.pack(index);
  packed_args.pack(reduce);
  packed_args.pack(self);
  packed_args.pack(src);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(include_self);
  saved.after(index_);
  saved.after(reduce);
  saved.after(self_);
  saved.after(src_);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list ReshapeCopyBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<c10::SymInt>& self_sym_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.reshape_symint(self_sym_sizes)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ReshapeCopyBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return ReshapeCopyBackward0_apply_functional(variable_list(grads), needs_input_grad, self_sym_sizes);
#endif
}

variable_list ReshapeCopyBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ReshapeCopyBackward0_apply_functional(std::move(grads), needs_input_grad, self_sym_sizes);
}

void ReshapeCopyBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_sym_sizes);
}
variable_list ReshapeCopyBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ReshapeCopyBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_sym_sizes);
  return output_result;
#endif
}

static variable_list ForeachDivBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, size_t self_size_, size_t other_size_, std::vector<Tensor>& other, std::vector<Tensor>& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto other_ix = gen.range(other_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*other*/1]) {  // other
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(div_tensor_other_backward(grads[i], self[i], other[i]));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, other_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(div_tensor_self_backward(grads[i], other[i], self[i].scalar_type()));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachDivBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto other_size_ = packed_args.unpack<size_t>();
  auto other = packed_args.unpack<std::vector<Tensor>>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  return ForeachDivBackward0_apply_functional(variable_list(grads), needs_input_grad, self_size_, other_size_, other, self);
#endif
}

variable_list ForeachDivBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!other_released_, ERR_BACKWARD_TWICE);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto other = unpack_list(other_, nullptr);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto other_ix = gen.range(other_size_);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  return ForeachDivBackward0_apply_functional(std::move(grads), needs_input_grad, self_size_, other_size_, other, self);
}

void ForeachDivBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(other_, false);
    args.collect(self_, false);
}
variable_list ForeachDivBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(other_);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachDivBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!other_released_, ERR_BACKWARD_TWICE);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto other = unpack_list(other_, nullptr);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto other_ix = gen.range(other_size_);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(other_size_);
  packed_args.pack(other);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(other_);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list ForeachPowBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, size_t self_size_, size_t exponent_size_, std::vector<Tensor>& exponent, std::vector<Tensor>& self, std::vector<Tensor>& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto exponent_ix = gen.range(exponent_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*exponent*/1]) {  // exponent
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(pow_backward_exponent(grads[i], self[i], exponent[i], result[i]));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, exponent_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(pow_backward_self(grads[i], self[i], exponent[i]));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachPowBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto exponent_size_ = packed_args.unpack<size_t>();
  auto exponent = packed_args.unpack<std::vector<Tensor>>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  auto result = packed_args.unpack<std::vector<Tensor>>();
  return ForeachPowBackward0_apply_functional(variable_list(grads), needs_input_grad, self_size_, exponent_size_, exponent, self, result);
#endif
}

variable_list ForeachPowBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!exponent_released_, ERR_BACKWARD_TWICE);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  TORCH_CHECK(!result_released_, ERR_BACKWARD_TWICE);
  auto exponent = unpack_list(exponent_, nullptr);
  auto self = unpack_list(self_, nullptr);
  auto result = unpack_list(result_, shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto exponent_ix = gen.range(exponent_size_);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ exponent_ix }),
  };
  return ForeachPowBackward0_apply_functional(std::move(grads), needs_input_grad, self_size_, exponent_size_, exponent, self, result);
}

void ForeachPowBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(exponent_, false);
    args.collect(self_, false);
    args.collect(result_, true);
}
variable_list ForeachPowBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(exponent_);
  saved.before(self_);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachPowBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!exponent_released_, ERR_BACKWARD_TWICE);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  TORCH_CHECK(!result_released_, ERR_BACKWARD_TWICE);
  auto exponent = unpack_list(exponent_, nullptr);
  auto self = unpack_list(self_, nullptr);
  auto result = unpack_list(result_, shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto exponent_ix = gen.range(exponent_size_);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ exponent_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(exponent_size_);
  packed_args.pack(exponent);
  packed_args.pack(self);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(exponent_);
  saved.after(self_);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list ForeachPowBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t self_size_, std::vector<at::Scalar>& exponent, std::vector<Tensor>& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(pow_backward(grads[i], self[i], exponent[i]));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachPowBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto exponent = packed_args.unpack<std::vector<at::Scalar>>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  return ForeachPowBackward1_apply_functional(variable_list(grads), needs_input_grad, self_size_, exponent, self);
#endif
}

variable_list ForeachPowBackward1::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ForeachPowBackward1_apply_functional(std::move(grads), needs_input_grad, self_size_, exponent, self);
}

void ForeachPowBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(exponent);
    args.collect(self_, false);
}
variable_list ForeachPowBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(exponent);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<at::Scalar>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachPowBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(exponent);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(exponent);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list ForeachPowBackward2_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t exponent_size_, std::vector<Tensor>& exponent, at::Scalar& self, std::vector<Tensor>& result)
{
  IndexRangeGenerator gen;
  auto exponent_ix = gen.range(exponent_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*exponent*/0]) {  // exponent
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(pow_backward_exponent(grads[i], self, exponent[i], result[i]));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, exponent_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachPowBackward2_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto exponent_size_ = packed_args.unpack<size_t>();
  auto exponent = packed_args.unpack<std::vector<Tensor>>();
  auto self = packed_args.unpack<at::Scalar>();
  auto result = packed_args.unpack<std::vector<Tensor>>();
  return ForeachPowBackward2_apply_functional(variable_list(grads), needs_input_grad, exponent_size_, exponent, self, result);
#endif
}

variable_list ForeachPowBackward2::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!exponent_released_, ERR_BACKWARD_TWICE);
  TORCH_CHECK(!result_released_, ERR_BACKWARD_TWICE);
  auto exponent = unpack_list(exponent_, nullptr);
  auto result = unpack_list(result_, shared_from_this());
  IndexRangeGenerator gen;
  auto exponent_ix = gen.range(exponent_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ exponent_ix }),
  };
  return ForeachPowBackward2_apply_functional(std::move(grads), needs_input_grad, exponent_size_, exponent, self, result);
}

void ForeachPowBackward2::compiled_args(CompiledNodeArgs& args) const {
    args.collect(exponent_, false);
    args.collect(self);
    args.collect(result_, true);
}
variable_list ForeachPowBackward2::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(exponent_);
  saved.before(self);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachPowBackward2_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!exponent_released_, ERR_BACKWARD_TWICE);
  TORCH_CHECK(!result_released_, ERR_BACKWARD_TWICE);
  auto exponent = unpack_list(exponent_, nullptr);
  auto result = unpack_list(result_, shared_from_this());
  IndexRangeGenerator gen;
  auto exponent_ix = gen.range(exponent_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ exponent_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(exponent_size_);
  packed_args.pack(exponent);
  packed_args.pack(self);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(exponent_);
  saved.after(self);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list ForeachMinimumBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t self_size_, at::Scalar& scalar, std::vector<Tensor>& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(at::where(self[i] == scalar, grads[i] / 2, grads[i]).masked_fill_(self[i] > scalar, 0));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachMinimumBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto scalar = packed_args.unpack<at::Scalar>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  return ForeachMinimumBackward0_apply_functional(variable_list(grads), needs_input_grad, self_size_, scalar, self);
#endif
}

variable_list ForeachMinimumBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ForeachMinimumBackward0_apply_functional(std::move(grads), needs_input_grad, self_size_, scalar, self);
}

void ForeachMinimumBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(scalar);
    args.collect(self_, false);
}
variable_list ForeachMinimumBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(scalar);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachMinimumBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(scalar);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(scalar);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list ForeachMinimumBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t self_size_, std::vector<at::Scalar>& scalars, std::vector<Tensor>& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(at::where(self[i] == scalars[i], grads[i] / 2, grads[i]).masked_fill_(self[i] > scalars[i], 0));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachMinimumBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto scalars = packed_args.unpack<std::vector<at::Scalar>>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  return ForeachMinimumBackward1_apply_functional(variable_list(grads), needs_input_grad, self_size_, scalars, self);
#endif
}

variable_list ForeachMinimumBackward1::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ForeachMinimumBackward1_apply_functional(std::move(grads), needs_input_grad, self_size_, scalars, self);
}

void ForeachMinimumBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(scalars);
    args.collect(self_, false);
}
variable_list ForeachMinimumBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(scalars);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<at::Scalar>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachMinimumBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(scalars);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(scalars);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list ForeachMaximumBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t self_size_, at::Scalar& scalar, std::vector<Tensor>& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(at::where(self[i] == scalar, grads[i] / 2, grads[i]).masked_fill_(self[i] < scalar, 0));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachMaximumBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto scalar = packed_args.unpack<at::Scalar>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  return ForeachMaximumBackward0_apply_functional(variable_list(grads), needs_input_grad, self_size_, scalar, self);
#endif
}

variable_list ForeachMaximumBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ForeachMaximumBackward0_apply_functional(std::move(grads), needs_input_grad, self_size_, scalar, self);
}

void ForeachMaximumBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(scalar);
    args.collect(self_, false);
}
variable_list ForeachMaximumBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(scalar);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachMaximumBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(scalar);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(scalar);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list ForeachMaximumBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t self_size_, std::vector<at::Scalar>& scalars, std::vector<Tensor>& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(at::where(self[i] == scalars[i], grads[i] / 2, grads[i]).masked_fill_(self[i] < scalars[i], 0));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachMaximumBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto scalars = packed_args.unpack<std::vector<at::Scalar>>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  return ForeachMaximumBackward1_apply_functional(variable_list(grads), needs_input_grad, self_size_, scalars, self);
#endif
}

variable_list ForeachMaximumBackward1::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ForeachMaximumBackward1_apply_functional(std::move(grads), needs_input_grad, self_size_, scalars, self);
}

void ForeachMaximumBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(scalars);
    args.collect(self_, false);
}
variable_list ForeachMaximumBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(scalars);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<at::Scalar>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachMaximumBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(scalars);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(scalars);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list ForeachNormBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t self_size_, at::Scalar& ord, std::vector<Tensor>& self, std::vector<Tensor>& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(norm_backward(grads[i], self[i], ord, result[i]));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachNormBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto ord = packed_args.unpack<at::Scalar>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  auto result = packed_args.unpack<std::vector<Tensor>>();
  return ForeachNormBackward0_apply_functional(variable_list(grads), needs_input_grad, self_size_, ord, self, result);
#endif
}

variable_list ForeachNormBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  TORCH_CHECK(!result_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  auto result = unpack_list(result_, shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ForeachNormBackward0_apply_functional(std::move(grads), needs_input_grad, self_size_, ord, self, result);
}

void ForeachNormBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(ord);
    args.collect(self_, false);
    args.collect(result_, true);
}
variable_list ForeachNormBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(ord);
  saved.before(self_);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachNormBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  TORCH_CHECK(!result_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  auto result = unpack_list(result_, shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(ord);
  packed_args.pack(self);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(ord);
  saved.after(self_);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list AliasBackward0_copy_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list AliasBackward0_copy_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return AliasBackward0_copy_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list AliasBackward0_copy::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return AliasBackward0_copy_apply_functional(std::move(grads), needs_input_grad);
}

void AliasBackward0_copy::compiled_args(CompiledNodeArgs& args) const {

}
variable_list AliasBackward0_copy::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), AliasBackward0_copy_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list AsStridedBackward0_copy_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, at::TensorGeometry& self_geometry, std::vector<c10::SymInt>& size, ::std::optional<c10::SymInt>& storage_offset, std::vector<c10::SymInt>& stride)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (as_strided_backward(grad, self_geometry, size, stride, storage_offset)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list AsStridedBackward0_copy_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_geometry = packed_args.unpack<at::TensorGeometry>();
  auto size = packed_args.unpack<std::vector<c10::SymInt>>();
  auto storage_offset = packed_args.unpack<::std::optional<c10::SymInt>>();
  auto stride = packed_args.unpack<std::vector<c10::SymInt>>();
  return AsStridedBackward0_copy_apply_functional(variable_list(grads), needs_input_grad, self_geometry, size, storage_offset, stride);
#endif
}

variable_list AsStridedBackward0_copy::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return AsStridedBackward0_copy_apply_functional(std::move(grads), needs_input_grad, self_geometry, size, storage_offset, stride);
}

void AsStridedBackward0_copy::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_geometry);
    args.collect(size);
    args.collect(storage_offset);
    args.collect(stride);
}
variable_list AsStridedBackward0_copy::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_geometry);
  saved.before(size);
  saved.before(storage_offset);
  saved.before(stride);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::TensorGeometry>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), AsStridedBackward0_copy_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_geometry);
  packed_args.pack(size);
  packed_args.pack(storage_offset);
  packed_args.pack(stride);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_geometry);
  saved.after(size);
  saved.after(storage_offset);
  saved.after(stride);
  return output_result;
#endif
}

static variable_list ConjBackward0_copy_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.conj()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ConjBackward0_copy_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return ConjBackward0_copy_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list ConjBackward0_copy::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ConjBackward0_copy_apply_functional(std::move(grads), needs_input_grad);
}

void ConjBackward0_copy::compiled_args(CompiledNodeArgs& args) const {

}
variable_list ConjBackward0_copy::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ConjBackward0_copy_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list NegViewBackward0_copy_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.neg()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list NegViewBackward0_copy_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return NegViewBackward0_copy_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list NegViewBackward0_copy::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return NegViewBackward0_copy_apply_functional(std::move(grads), needs_input_grad);
}

void NegViewBackward0_copy::compiled_args(CompiledNodeArgs& args) const {

}
variable_list NegViewBackward0_copy::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), NegViewBackward0_copy_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list DiagonalBackward0_copy_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim1, int64_t& dim2, int64_t& offset, std::vector<c10::SymInt>& self_sym_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (diagonal_backward_symint(grad, self_sym_sizes, offset, dim1, dim2)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list DiagonalBackward0_copy_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim1 = packed_args.unpack<int64_t>();
  auto dim2 = packed_args.unpack<int64_t>();
  auto offset = packed_args.unpack<int64_t>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return DiagonalBackward0_copy_apply_functional(variable_list(grads), needs_input_grad, dim1, dim2, offset, self_sym_sizes);
#endif
}

variable_list DiagonalBackward0_copy::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return DiagonalBackward0_copy_apply_functional(std::move(grads), needs_input_grad, dim1, dim2, offset, self_sym_sizes);
}

void DiagonalBackward0_copy::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim1);
    args.collect(dim2);
    args.collect(offset);
    args.collect(self_sym_sizes);
}
variable_list DiagonalBackward0_copy::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim1);
  saved.before(dim2);
  saved.before(offset);
  saved.before(self_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), DiagonalBackward0_copy_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim1);
  packed_args.pack(dim2);
  packed_args.pack(offset);
  packed_args.pack(self_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim1);
  saved.after(dim2);
  saved.after(offset);
  saved.after(self_sym_sizes);
  return output_result;
#endif
}

static variable_list ExpandBackward0_copy_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<c10::SymInt>& self_sym_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (at::sum_to(grad, self_sym_sizes)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ExpandBackward0_copy_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return ExpandBackward0_copy_apply_functional(variable_list(grads), needs_input_grad, self_sym_sizes);
#endif
}

variable_list ExpandBackward0_copy::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ExpandBackward0_copy_apply_functional(std::move(grads), needs_input_grad, self_sym_sizes);
}

void ExpandBackward0_copy::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_sym_sizes);
}
variable_list ExpandBackward0_copy::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ExpandBackward0_copy_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_sym_sizes);
  return output_result;
#endif
}

static variable_list PermuteBackward0_copy_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<int64_t>& dims)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (permute_backwards(grad, dims)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list PermuteBackward0_copy_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dims = packed_args.unpack<std::vector<int64_t>>();
  return PermuteBackward0_copy_apply_functional(variable_list(grads), needs_input_grad, dims);
#endif
}

variable_list PermuteBackward0_copy::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return PermuteBackward0_copy_apply_functional(std::move(grads), needs_input_grad, dims);
}

void PermuteBackward0_copy::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dims);
}
variable_list PermuteBackward0_copy::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dims);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), PermuteBackward0_copy_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dims);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dims);
  return output_result;
#endif
}

static variable_list ReshapeAliasBackward0_copy_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<c10::SymInt>& self_sym_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.reshape_symint(self_sym_sizes)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ReshapeAliasBackward0_copy_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return ReshapeAliasBackward0_copy_apply_functional(variable_list(grads), needs_input_grad, self_sym_sizes);
#endif
}

variable_list ReshapeAliasBackward0_copy::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ReshapeAliasBackward0_copy_apply_functional(std::move(grads), needs_input_grad, self_sym_sizes);
}

void ReshapeAliasBackward0_copy::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_sym_sizes);
}
variable_list ReshapeAliasBackward0_copy::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ReshapeAliasBackward0_copy_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_sym_sizes);
  return output_result;
#endif
}

static variable_list SelectBackward0_copy_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim, c10::SymInt& index, std::vector<c10::SymInt>& self_sym_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (select_backward_symint(grad, self_sym_sizes, dim, index)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SelectBackward0_copy_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  auto index = packed_args.unpack<c10::SymInt>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return SelectBackward0_copy_apply_functional(variable_list(grads), needs_input_grad, dim, index, self_sym_sizes);
#endif
}

variable_list SelectBackward0_copy::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SelectBackward0_copy_apply_functional(std::move(grads), needs_input_grad, dim, index, self_sym_sizes);
}

void SelectBackward0_copy::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(index);
    args.collect(self_sym_sizes);
}
variable_list SelectBackward0_copy::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(index);
  saved.before(self_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SelectBackward0_copy_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(index);
  packed_args.pack(self_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(index);
  saved.after(self_sym_sizes);
  return output_result;
#endif
}

static variable_list SelectBackwardAutogradNestedTensor0_copy_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim, c10::SymInt& index, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (_nested_select_backward_symint(grad, self, dim, index)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SelectBackwardAutogradNestedTensor0_copy_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  auto index = packed_args.unpack<c10::SymInt>();
  auto self = packed_args.unpack<Tensor>();
  return SelectBackwardAutogradNestedTensor0_copy_apply_functional(variable_list(grads), needs_input_grad, dim, index, self);
#endif
}

variable_list SelectBackwardAutogradNestedTensor0_copy::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SelectBackwardAutogradNestedTensor0_copy_apply_functional(std::move(grads), needs_input_grad, dim, index, self);
}

void SelectBackwardAutogradNestedTensor0_copy::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(index);
    args.collect(self_, false);
}
variable_list SelectBackwardAutogradNestedTensor0_copy::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(index);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SelectBackwardAutogradNestedTensor0_copy_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(index);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(index);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list SliceBackward0_copy_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim, ::std::optional<c10::SymInt>& end, std::vector<c10::SymInt>& self_sym_sizes, ::std::optional<c10::SymInt>& start, c10::SymInt& step)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (slice_backward_wrapper(grad, self_sym_sizes, dim, start, end, step)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SliceBackward0_copy_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  auto end = packed_args.unpack<::std::optional<c10::SymInt>>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  auto start = packed_args.unpack<::std::optional<c10::SymInt>>();
  auto step = packed_args.unpack<c10::SymInt>();
  return SliceBackward0_copy_apply_functional(variable_list(grads), needs_input_grad, dim, end, self_sym_sizes, start, step);
#endif
}

variable_list SliceBackward0_copy::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SliceBackward0_copy_apply_functional(std::move(grads), needs_input_grad, dim, end, self_sym_sizes, start, step);
}

void SliceBackward0_copy::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(end);
    args.collect(self_sym_sizes);
    args.collect(start);
    args.collect(step);
}
variable_list SliceBackward0_copy::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(end);
  saved.before(self_sym_sizes);
  saved.before(start);
  saved.before(step);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<::std::optional<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SliceBackward0_copy_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(end);
  packed_args.pack(self_sym_sizes);
  packed_args.pack(start);
  packed_args.pack(step);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(end);
  saved.after(self_sym_sizes);
  saved.after(start);
  saved.after(step);
  return output_result;
#endif
}

static variable_list SplitBackward0_copy_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim, at::TensorOptions& self_options, std::vector<c10::SymInt>& self_sym_sizes, c10::SymInt& split_size)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (split_backward(grads, split_size, dim, self_sym_sizes, self_options)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SplitBackward0_copy_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  auto self_options = packed_args.unpack<at::TensorOptions>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  auto split_size = packed_args.unpack<c10::SymInt>();
  return SplitBackward0_copy_apply_functional(variable_list(grads), needs_input_grad, dim, self_options, self_sym_sizes, split_size);
#endif
}

variable_list SplitBackward0_copy::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SplitBackward0_copy_apply_functional(std::move(grads), needs_input_grad, dim, self_options, self_sym_sizes, split_size);
}

void SplitBackward0_copy::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(self_options);
    args.collect(self_sym_sizes);
    args.collect(split_size);
}
variable_list SplitBackward0_copy::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(self_options);
  saved.before(self_sym_sizes);
  saved.before(split_size);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::TensorOptions>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<c10::SymInt>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SplitBackward0_copy_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(self_options);
  packed_args.pack(self_sym_sizes);
  packed_args.pack(split_size);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(self_options);
  saved.after(self_sym_sizes);
  saved.after(split_size);
  return output_result;
#endif
}

static variable_list SplitWithSizesBackward0_copy_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim, at::TensorOptions& self_options, std::vector<c10::SymInt>& self_sym_sizes, std::vector<c10::SymInt>& split_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (split_with_sizes_backward(grads, split_sizes, dim, self_sym_sizes, self_options)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SplitWithSizesBackward0_copy_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  auto self_options = packed_args.unpack<at::TensorOptions>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  auto split_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return SplitWithSizesBackward0_copy_apply_functional(variable_list(grads), needs_input_grad, dim, self_options, self_sym_sizes, split_sizes);
#endif
}

variable_list SplitWithSizesBackward0_copy::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SplitWithSizesBackward0_copy_apply_functional(std::move(grads), needs_input_grad, dim, self_options, self_sym_sizes, split_sizes);
}

void SplitWithSizesBackward0_copy::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(self_options);
    args.collect(self_sym_sizes);
    args.collect(split_sizes);
}
variable_list SplitWithSizesBackward0_copy::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(self_options);
  saved.before(self_sym_sizes);
  saved.before(split_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::TensorOptions>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SplitWithSizesBackward0_copy_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(self_options);
  packed_args.pack(self_sym_sizes);
  packed_args.pack(split_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(self_options);
  saved.after(self_sym_sizes);
  saved.after(split_sizes);
  return output_result;
#endif
}

static variable_list SplitWithSizesBackwardAutogradNestedTensor0_copy_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim, Tensor& self, at::TensorOptions& self_options, std::vector<c10::SymInt>& split_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (_nested_split_with_sizes_backward(grads, split_sizes, dim, at::native::get_nested_tensor_impl(self)->get_nested_sizes(), self_options)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SplitWithSizesBackwardAutogradNestedTensor0_copy_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  auto self = packed_args.unpack<Tensor>();
  auto self_options = packed_args.unpack<at::TensorOptions>();
  auto split_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return SplitWithSizesBackwardAutogradNestedTensor0_copy_apply_functional(variable_list(grads), needs_input_grad, dim, self, self_options, split_sizes);
#endif
}

variable_list SplitWithSizesBackwardAutogradNestedTensor0_copy::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SplitWithSizesBackwardAutogradNestedTensor0_copy_apply_functional(std::move(grads), needs_input_grad, dim, self, self_options, split_sizes);
}

void SplitWithSizesBackwardAutogradNestedTensor0_copy::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(self_, false);
    args.collect(self_options);
    args.collect(split_sizes);
}
variable_list SplitWithSizesBackwardAutogradNestedTensor0_copy::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(self_);
  saved.before(self_options);
  saved.before(split_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::TensorOptions>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SplitWithSizesBackwardAutogradNestedTensor0_copy_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(self);
  packed_args.pack(self_options);
  packed_args.pack(split_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(self_);
  saved.after(self_options);
  saved.after(split_sizes);
  return output_result;
#endif
}

static variable_list SqueezeBackward0_copy_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<c10::SymInt>& self_sym_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (unsqueeze_to(grad, self_sym_sizes)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SqueezeBackward0_copy_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return SqueezeBackward0_copy_apply_functional(variable_list(grads), needs_input_grad, self_sym_sizes);
#endif
}

variable_list SqueezeBackward0_copy::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SqueezeBackward0_copy_apply_functional(std::move(grads), needs_input_grad, self_sym_sizes);
}

void SqueezeBackward0_copy::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_sym_sizes);
}
variable_list SqueezeBackward0_copy::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SqueezeBackward0_copy_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_sym_sizes);
  return output_result;
#endif
}

static variable_list SqueezeBackward1_copy_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim, std::vector<c10::SymInt>& self_sym_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (unsqueeze_to(grad, dim, self_sym_sizes)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SqueezeBackward1_copy_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return SqueezeBackward1_copy_apply_functional(variable_list(grads), needs_input_grad, dim, self_sym_sizes);
#endif
}

variable_list SqueezeBackward1_copy::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SqueezeBackward1_copy_apply_functional(std::move(grads), needs_input_grad, dim, self_sym_sizes);
}

void SqueezeBackward1_copy::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(self_sym_sizes);
}
variable_list SqueezeBackward1_copy::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(self_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SqueezeBackward1_copy_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(self_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(self_sym_sizes);
  return output_result;
#endif
}

static variable_list SqueezeBackwardAutogradNestedTensor0_copy_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.unsqueeze(dim)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SqueezeBackwardAutogradNestedTensor0_copy_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  return SqueezeBackwardAutogradNestedTensor0_copy_apply_functional(variable_list(grads), needs_input_grad, dim);
#endif
}

variable_list SqueezeBackwardAutogradNestedTensor0_copy::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SqueezeBackwardAutogradNestedTensor0_copy_apply_functional(std::move(grads), needs_input_grad, dim);
}

void SqueezeBackwardAutogradNestedTensor0_copy::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
}
variable_list SqueezeBackwardAutogradNestedTensor0_copy::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SqueezeBackwardAutogradNestedTensor0_copy_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  return output_result;
#endif
}

static variable_list SqueezeBackward2_copy_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<int64_t>& dim, std::vector<c10::SymInt>& self_sym_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (unsqueeze_to(grad, dim, self_sym_sizes)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SqueezeBackward2_copy_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<std::vector<int64_t>>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return SqueezeBackward2_copy_apply_functional(variable_list(grads), needs_input_grad, dim, self_sym_sizes);
#endif
}

variable_list SqueezeBackward2_copy::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SqueezeBackward2_copy_apply_functional(std::move(grads), needs_input_grad, dim, self_sym_sizes);
}

void SqueezeBackward2_copy::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(self_sym_sizes);
}
variable_list SqueezeBackward2_copy::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(self_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SqueezeBackward2_copy_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(self_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(self_sym_sizes);
  return output_result;
#endif
}

static variable_list SqueezeBackwardAutogradNestedTensor1_copy_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<int64_t>& dim, int64_t& self_dim)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (unsqueeze_multiple(grad, dim, self_dim)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list SqueezeBackwardAutogradNestedTensor1_copy_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<std::vector<int64_t>>();
  auto self_dim = packed_args.unpack<int64_t>();
  return SqueezeBackwardAutogradNestedTensor1_copy_apply_functional(variable_list(grads), needs_input_grad, dim, self_dim);
#endif
}

variable_list SqueezeBackwardAutogradNestedTensor1_copy::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return SqueezeBackwardAutogradNestedTensor1_copy_apply_functional(std::move(grads), needs_input_grad, dim, self_dim);
}

void SqueezeBackwardAutogradNestedTensor1_copy::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(self_dim);
}
variable_list SqueezeBackwardAutogradNestedTensor1_copy::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(self_dim);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<int64_t>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), SqueezeBackwardAutogradNestedTensor1_copy_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(self_dim);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(self_dim);
  return output_result;
#endif
}

static variable_list TBackward0_copy_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.t()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list TBackward0_copy_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return TBackward0_copy_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list TBackward0_copy::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return TBackward0_copy_apply_functional(std::move(grads), needs_input_grad);
}

void TBackward0_copy::compiled_args(CompiledNodeArgs& args) const {

}
variable_list TBackward0_copy::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), TBackward0_copy_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list TransposeBackward0_copy_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim0, int64_t& dim1)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.transpose(dim0, dim1)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list TransposeBackward0_copy_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim0 = packed_args.unpack<int64_t>();
  auto dim1 = packed_args.unpack<int64_t>();
  return TransposeBackward0_copy_apply_functional(variable_list(grads), needs_input_grad, dim0, dim1);
#endif
}

variable_list TransposeBackward0_copy::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return TransposeBackward0_copy_apply_functional(std::move(grads), needs_input_grad, dim0, dim1);
}

void TransposeBackward0_copy::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim0);
    args.collect(dim1);
}
variable_list TransposeBackward0_copy::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim0);
  saved.before(dim1);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), TransposeBackward0_copy_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim0);
  packed_args.pack(dim1);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim0);
  saved.after(dim1);
  return output_result;
#endif
}

static variable_list UnfoldBackward0_copy_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dimension, std::vector<c10::SymInt>& self_sym_sizes, int64_t& size, int64_t& step)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (unfold_backward_symint(grad, self_sym_sizes, dimension, size, step)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list UnfoldBackward0_copy_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dimension = packed_args.unpack<int64_t>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  auto size = packed_args.unpack<int64_t>();
  auto step = packed_args.unpack<int64_t>();
  return UnfoldBackward0_copy_apply_functional(variable_list(grads), needs_input_grad, dimension, self_sym_sizes, size, step);
#endif
}

variable_list UnfoldBackward0_copy::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return UnfoldBackward0_copy_apply_functional(std::move(grads), needs_input_grad, dimension, self_sym_sizes, size, step);
}

void UnfoldBackward0_copy::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dimension);
    args.collect(self_sym_sizes);
    args.collect(size);
    args.collect(step);
}
variable_list UnfoldBackward0_copy::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dimension);
  saved.before(self_sym_sizes);
  saved.before(size);
  saved.before(step);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), UnfoldBackward0_copy_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dimension);
  packed_args.pack(self_sym_sizes);
  packed_args.pack(size);
  packed_args.pack(step);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dimension);
  saved.after(self_sym_sizes);
  saved.after(size);
  saved.after(step);
  return output_result;
#endif
}

static variable_list LiftFreshBackward0_copy_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list LiftFreshBackward0_copy_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return LiftFreshBackward0_copy_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list LiftFreshBackward0_copy::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return LiftFreshBackward0_copy_apply_functional(std::move(grads), needs_input_grad);
}

void LiftFreshBackward0_copy::compiled_args(CompiledNodeArgs& args) const {

}
variable_list LiftFreshBackward0_copy::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), LiftFreshBackward0_copy_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list UnsqueezeBackward0_copy_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.squeeze(dim)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list UnsqueezeBackward0_copy_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  return UnsqueezeBackward0_copy_apply_functional(variable_list(grads), needs_input_grad, dim);
#endif
}

variable_list UnsqueezeBackward0_copy::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return UnsqueezeBackward0_copy_apply_functional(std::move(grads), needs_input_grad, dim);
}

void UnsqueezeBackward0_copy::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
}
variable_list UnsqueezeBackward0_copy::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), UnsqueezeBackward0_copy_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  return output_result;
#endif
}

static variable_list ViewBackward0_copy_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, std::vector<c10::SymInt>& self_sym_sizes)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.reshape_symint(self_sym_sizes)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ViewBackward0_copy_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_sym_sizes = packed_args.unpack<std::vector<c10::SymInt>>();
  return ViewBackward0_copy_apply_functional(variable_list(grads), needs_input_grad, self_sym_sizes);
#endif
}

variable_list ViewBackward0_copy::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ViewBackward0_copy_apply_functional(std::move(grads), needs_input_grad, self_sym_sizes);
}

void ViewBackward0_copy::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_sym_sizes);
}
variable_list ViewBackward0_copy::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_sym_sizes);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<c10::SymInt>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ViewBackward0_copy_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_sym_sizes);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_sym_sizes);
  return output_result;
#endif
}

static variable_list ViewBackwardAutogradNestedTensor0_copy_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.reshape_as(self)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ViewBackwardAutogradNestedTensor0_copy_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  return ViewBackwardAutogradNestedTensor0_copy_apply_functional(variable_list(grads), needs_input_grad, self);
#endif
}

variable_list ViewBackwardAutogradNestedTensor0_copy::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ViewBackwardAutogradNestedTensor0_copy_apply_functional(std::move(grads), needs_input_grad, self);
}

void ViewBackwardAutogradNestedTensor0_copy::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list ViewBackwardAutogradNestedTensor0_copy::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ViewBackwardAutogradNestedTensor0_copy_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list ViewAsRealBackward0_copy_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (at::view_as_complex(grad.contiguous())) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ViewAsRealBackward0_copy_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return ViewAsRealBackward0_copy_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list ViewAsRealBackward0_copy::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ViewAsRealBackward0_copy_apply_functional(std::move(grads), needs_input_grad);
}

void ViewAsRealBackward0_copy::compiled_args(CompiledNodeArgs& args) const {

}
variable_list ViewAsRealBackward0_copy::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ViewAsRealBackward0_copy_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list ViewAsComplexBackward0_copy_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (at::view_as_real(grad.contiguous().resolve_conj())) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ViewAsComplexBackward0_copy_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return ViewAsComplexBackward0_copy_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list ViewAsComplexBackward0_copy::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ViewAsComplexBackward0_copy_apply_functional(std::move(grads), needs_input_grad);
}

void ViewAsComplexBackward0_copy::compiled_args(CompiledNodeArgs& args) const {

}
variable_list ViewAsComplexBackward0_copy::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ViewAsComplexBackward0_copy_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list ValuesBackward0_copy_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (values_backward(grad, self)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ValuesBackward0_copy_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  return ValuesBackward0_copy_apply_functional(variable_list(grads), needs_input_grad, self);
#endif
}

variable_list ValuesBackward0_copy::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ValuesBackward0_copy_apply_functional(std::move(grads), needs_input_grad, self);
}

void ValuesBackward0_copy::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list ValuesBackward0_copy::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ValuesBackward0_copy_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list ValuesBackwardAutogradNestedTensor0_copy_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (at::_nested_view_from_buffer(grad.contiguous(), self._nested_tensor_size(), self._nested_tensor_strides(), self._nested_tensor_storage_offsets())) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ValuesBackwardAutogradNestedTensor0_copy_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  return ValuesBackwardAutogradNestedTensor0_copy_apply_functional(variable_list(grads), needs_input_grad, self);
#endif
}

variable_list ValuesBackwardAutogradNestedTensor0_copy::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ValuesBackwardAutogradNestedTensor0_copy_apply_functional(std::move(grads), needs_input_grad, self);
}

void ValuesBackwardAutogradNestedTensor0_copy::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list ValuesBackwardAutogradNestedTensor0_copy::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ValuesBackwardAutogradNestedTensor0_copy_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list NestedViewFromBufferBackward0_copy_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.values()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list NestedViewFromBufferBackward0_copy_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return NestedViewFromBufferBackward0_copy_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list NestedViewFromBufferBackward0_copy::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return NestedViewFromBufferBackward0_copy_apply_functional(std::move(grads), needs_input_grad);
}

void NestedViewFromBufferBackward0_copy::compiled_args(CompiledNodeArgs& args) const {

}
variable_list NestedViewFromBufferBackward0_copy::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), NestedViewFromBufferBackward0_copy_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list NestedViewFromJaggedBackward0_copy_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.values()) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list NestedViewFromJaggedBackward0_copy_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();

  return NestedViewFromJaggedBackward0_copy_apply_functional(variable_list(grads), needs_input_grad);
#endif
}

variable_list NestedViewFromJaggedBackward0_copy::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return NestedViewFromJaggedBackward0_copy_apply_functional(std::move(grads), needs_input_grad);
}

void NestedViewFromJaggedBackward0_copy::compiled_args(CompiledNodeArgs& args) const {

}
variable_list NestedViewFromJaggedBackward0_copy::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), NestedViewFromJaggedBackward0_copy_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);


  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list NestedGetValuesBackward0_copy_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (_nested_view_from_jagged(grad, at::_nested_get_offsets(self), at::_nested_get_jagged_dummy(self), at::_nested_get_lengths(self), at::_nested_get_ragged_idx(self), at::_nested_get_min_seqlen(self).defined() ? std::optional<Tensor>(at::_nested_get_min_seqlen(self)) : ::std::nullopt, at::_nested_get_max_seqlen(self).defined() ? std::optional<Tensor>(at::_nested_get_max_seqlen(self)) : ::std::nullopt)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list NestedGetValuesBackward0_copy_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  return NestedGetValuesBackward0_copy_apply_functional(variable_list(grads), needs_input_grad, self);
#endif
}

variable_list NestedGetValuesBackward0_copy::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return NestedGetValuesBackward0_copy_apply_functional(std::move(grads), needs_input_grad, self);
}

void NestedGetValuesBackward0_copy::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list NestedGetValuesBackward0_copy::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), NestedGetValuesBackward0_copy_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list UnbindBackward0_copy_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (unbind_backward(grads, dim)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list UnbindBackward0_copy_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  return UnbindBackward0_copy_apply_functional(variable_list(grads), needs_input_grad, dim);
#endif
}

variable_list UnbindBackward0_copy::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return UnbindBackward0_copy_apply_functional(std::move(grads), needs_input_grad, dim);
}

void UnbindBackward0_copy::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
}
variable_list UnbindBackward0_copy::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), UnbindBackward0_copy_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  return output_result;
#endif
}

static variable_list UnbindBackwardAutogradNestedTensor0_copy_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, int64_t& dim, Tensor& self, at::Layout& self_layout, at::TensorOptions& self_options)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (self_layout == c10::kJagged ? unbind_backward_nested_jagged(grads, self, dim) : unbind_backward_nested(grads, at::native::get_nested_tensor_impl(self)->get_nested_sizes(), dim, self_options)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list UnbindBackwardAutogradNestedTensor0_copy_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto dim = packed_args.unpack<int64_t>();
  auto self = packed_args.unpack<Tensor>();
  auto self_layout = packed_args.unpack<at::Layout>();
  auto self_options = packed_args.unpack<at::TensorOptions>();
  return UnbindBackwardAutogradNestedTensor0_copy_apply_functional(variable_list(grads), needs_input_grad, dim, self, self_layout, self_options);
#endif
}

variable_list UnbindBackwardAutogradNestedTensor0_copy::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return UnbindBackwardAutogradNestedTensor0_copy_apply_functional(std::move(grads), needs_input_grad, dim, self, self_layout, self_options);
}

void UnbindBackwardAutogradNestedTensor0_copy::compiled_args(CompiledNodeArgs& args) const {
    args.collect(dim);
    args.collect(self_, false);
    args.collect(self_layout);
    args.collect(self_options);
}
variable_list UnbindBackwardAutogradNestedTensor0_copy::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(dim);
  saved.before(self_);
  saved.before(self_layout);
  saved.before(self_options);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<int64_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Layout>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::TensorOptions>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), UnbindBackwardAutogradNestedTensor0_copy_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(dim);
  packed_args.pack(self);
  packed_args.pack(self_layout);
  packed_args.pack(self_options);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(dim);
  saved.after(self_);
  saved.after(self_layout);
  saved.after(self_options);
  return output_result;
#endif
}

static variable_list TestAutogradMultipleDispatchViewBackward0_copy_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.reshape_as(self)) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list TestAutogradMultipleDispatchViewBackward0_copy_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  return TestAutogradMultipleDispatchViewBackward0_copy_apply_functional(variable_list(grads), needs_input_grad, self);
#endif
}

variable_list TestAutogradMultipleDispatchViewBackward0_copy::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return TestAutogradMultipleDispatchViewBackward0_copy_apply_functional(std::move(grads), needs_input_grad, self);
}

void TestAutogradMultipleDispatchViewBackward0_copy::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list TestAutogradMultipleDispatchViewBackward0_copy::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), TestAutogradMultipleDispatchViewBackward0_copy_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list TestAutogradMultipleDispatchViewBackwardAutogradCUDA0_copy_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, Tensor& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  const auto& grad = grads[0];
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*self*/0]) {
    auto grad_result = any_grad_defined ? (grad.reshape_as(self) + 1) : Tensor();
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list TestAutogradMultipleDispatchViewBackwardAutogradCUDA0_copy_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self = packed_args.unpack<Tensor>();
  return TestAutogradMultipleDispatchViewBackwardAutogradCUDA0_copy_apply_functional(variable_list(grads), needs_input_grad, self);
#endif
}

variable_list TestAutogradMultipleDispatchViewBackwardAutogradCUDA0_copy::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return TestAutogradMultipleDispatchViewBackwardAutogradCUDA0_copy_apply_functional(std::move(grads), needs_input_grad, self);
}

void TestAutogradMultipleDispatchViewBackwardAutogradCUDA0_copy::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list TestAutogradMultipleDispatchViewBackwardAutogradCUDA0_copy::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), TestAutogradMultipleDispatchViewBackwardAutogradCUDA0_copy_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;

  auto self = self_.unpack();
  IndexRangeGenerator gen;
  auto self_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list ForeachAbsBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t self_size_, std::vector<Tensor>& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(grads[i] * self[i].sgn());
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachAbsBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  return ForeachAbsBackward0_apply_functional(variable_list(grads), needs_input_grad, self_size_, self);
#endif
}

variable_list ForeachAbsBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ForeachAbsBackward0_apply_functional(std::move(grads), needs_input_grad, self_size_, self);
}

void ForeachAbsBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list ForeachAbsBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachAbsBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list ForeachAcosBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t self_size_, std::vector<Tensor>& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(grads[i] * -((-self[i] * self[i] + 1).rsqrt()).conj());
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachAcosBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  return ForeachAcosBackward0_apply_functional(variable_list(grads), needs_input_grad, self_size_, self);
#endif
}

variable_list ForeachAcosBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ForeachAcosBackward0_apply_functional(std::move(grads), needs_input_grad, self_size_, self);
}

void ForeachAcosBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list ForeachAcosBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachAcosBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list ForeachAddBackward1Scalar_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t self_size_, std::vector<Tensor>& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(handle_r_to_c(self[i].scalar_type(), grads[i]));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachAddBackward1Scalar_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  return ForeachAddBackward1Scalar_apply_functional(variable_list(grads), needs_input_grad, self_size_, self);
#endif
}

variable_list ForeachAddBackward1Scalar::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ForeachAddBackward1Scalar_apply_functional(std::move(grads), needs_input_grad, self_size_, self);
}

void ForeachAddBackward1Scalar::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list ForeachAddBackward1Scalar::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachAddBackward1Scalar_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list ForeachAddBackward0List_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, size_t self_size_, size_t other_size_, at::Scalar& alpha, std::vector<Tensor>& other, std::vector<Tensor>& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto other_ix = gen.range(other_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*other*/1]) {  // other
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(handle_r_to_c(other[i].scalar_type(), maybe_multiply(grads[i], alpha.conj())));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, other_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(handle_r_to_c(self[i].scalar_type(), grads[i]));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachAddBackward0List_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto other_size_ = packed_args.unpack<size_t>();
  auto alpha = packed_args.unpack<at::Scalar>();
  auto other = packed_args.unpack<std::vector<Tensor>>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  return ForeachAddBackward0List_apply_functional(variable_list(grads), needs_input_grad, self_size_, other_size_, alpha, other, self);
#endif
}

variable_list ForeachAddBackward0List::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!other_released_, ERR_BACKWARD_TWICE);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto other = unpack_list(other_, nullptr);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto other_ix = gen.range(other_size_);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  return ForeachAddBackward0List_apply_functional(std::move(grads), needs_input_grad, self_size_, other_size_, alpha, other, self);
}

void ForeachAddBackward0List::compiled_args(CompiledNodeArgs& args) const {
    args.collect(alpha);
    args.collect(other_, false);
    args.collect(self_, false);
}
variable_list ForeachAddBackward0List::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(alpha);
  saved.before(other_);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachAddBackward0List_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!other_released_, ERR_BACKWARD_TWICE);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto other = unpack_list(other_, nullptr);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto other_ix = gen.range(other_size_);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(other_size_);
  packed_args.pack(alpha);
  packed_args.pack(other);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(alpha);
  saved.after(other_);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list ForeachAddBackward1ScalarList_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t self_size_, std::vector<Tensor>& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(handle_r_to_c(self[i].scalar_type(), grads[i]));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachAddBackward1ScalarList_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  return ForeachAddBackward1ScalarList_apply_functional(variable_list(grads), needs_input_grad, self_size_, self);
#endif
}

variable_list ForeachAddBackward1ScalarList::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ForeachAddBackward1ScalarList_apply_functional(std::move(grads), needs_input_grad, self_size_, self);
}

void ForeachAddBackward1ScalarList::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list ForeachAddBackward1ScalarList::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachAddBackward1ScalarList_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list ForeachAddBackward0Tensor_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, size_t self_size_, at::Scalar& alpha, Tensor& other, std::vector<Tensor>& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto other_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*other*/1]) {  // other
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(any_grad_defined ? (handle_r_to_c(other.scalar_type(), maybe_multiply(grads[i], alpha.conj()))) : Tensor());
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, other_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(handle_r_to_c(self[i].scalar_type(), grads[i]));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachAddBackward0Tensor_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto alpha = packed_args.unpack<at::Scalar>();
  auto other = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  return ForeachAddBackward0Tensor_apply_functional(variable_list(grads), needs_input_grad, self_size_, alpha, other, self);
#endif
}

variable_list ForeachAddBackward0Tensor::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto other = other_.unpack();
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  return ForeachAddBackward0Tensor_apply_functional(std::move(grads), needs_input_grad, self_size_, alpha, other, self);
}

void ForeachAddBackward0Tensor::compiled_args(CompiledNodeArgs& args) const {
    args.collect(alpha);
    args.collect(other_, false);
    args.collect(self_, false);
}
variable_list ForeachAddBackward0Tensor::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(alpha);
  saved.before(other_);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachAddBackward0Tensor_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto other = other_.unpack();
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(alpha);
  packed_args.pack(other);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(alpha);
  saved.after(other_);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list ForeachAddcdivBackward0Scalar_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, size_t self_size_, size_t tensor1_size_, size_t tensor2_size_, std::vector<Tensor>& self, std::vector<Tensor>& tensor1, std::vector<Tensor>& tensor2, at::Scalar& value)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto tensor1_ix = gen.range(tensor1_size_);
  auto tensor2_ix = gen.range(tensor2_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(handle_r_to_c(self[i].scalar_type(), grads[i]));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  if (needs_input_grad[/*tensor1*/1]) {  // tensor1
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(handle_r_to_c(tensor1[i].scalar_type(), grads[i] * (value / tensor2[i]).conj()));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, tensor1_ix, grad_result);
  }
  if (needs_input_grad[/*tensor2*/2]) {  // tensor2
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(handle_r_to_c(tensor2[i][i].scalar_type(), -grads[i] * (value * tensor1[i] / (tensor2[i] * tensor2[i])).conj()));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, tensor2_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachAddcdivBackward0Scalar_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto tensor1_size_ = packed_args.unpack<size_t>();
  auto tensor2_size_ = packed_args.unpack<size_t>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  auto tensor1 = packed_args.unpack<std::vector<Tensor>>();
  auto tensor2 = packed_args.unpack<std::vector<Tensor>>();
  auto value = packed_args.unpack<at::Scalar>();
  return ForeachAddcdivBackward0Scalar_apply_functional(variable_list(grads), needs_input_grad, self_size_, tensor1_size_, tensor2_size_, self, tensor1, tensor2, value);
#endif
}

variable_list ForeachAddcdivBackward0Scalar::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  TORCH_CHECK(!tensor1_released_, ERR_BACKWARD_TWICE);
  TORCH_CHECK(!tensor2_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  auto tensor1 = unpack_list(tensor1_, nullptr);
  auto tensor2 = unpack_list(tensor2_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto tensor1_ix = gen.range(tensor1_size_);
  auto tensor2_ix = gen.range(tensor2_size_);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ tensor1_ix }),
    task_should_compute_output({ tensor2_ix }),
  };
  return ForeachAddcdivBackward0Scalar_apply_functional(std::move(grads), needs_input_grad, self_size_, tensor1_size_, tensor2_size_, self, tensor1, tensor2, value);
}

void ForeachAddcdivBackward0Scalar::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
    args.collect(tensor1_, false);
    args.collect(tensor2_, false);
    args.collect(value);
}
variable_list ForeachAddcdivBackward0Scalar::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);
  saved.before(tensor1_);
  saved.before(tensor2_);
  saved.before(value);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachAddcdivBackward0Scalar_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  TORCH_CHECK(!tensor1_released_, ERR_BACKWARD_TWICE);
  TORCH_CHECK(!tensor2_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  auto tensor1 = unpack_list(tensor1_, nullptr);
  auto tensor2 = unpack_list(tensor2_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto tensor1_ix = gen.range(tensor1_size_);
  auto tensor2_ix = gen.range(tensor2_size_);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ tensor1_ix }),
    task_should_compute_output({ tensor2_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(tensor1_size_);
  packed_args.pack(tensor2_size_);
  packed_args.pack(self);
  packed_args.pack(tensor1);
  packed_args.pack(tensor2);
  packed_args.pack(value);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  saved.after(tensor1_);
  saved.after(tensor2_);
  saved.after(value);
  return output_result;
#endif
}

static variable_list ForeachAddcdivBackward0ScalarList_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, size_t self_size_, size_t tensor1_size_, size_t tensor2_size_, std::vector<at::Scalar>& scalars, std::vector<Tensor>& self, std::vector<Tensor>& tensor1, std::vector<Tensor>& tensor2)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto tensor1_ix = gen.range(tensor1_size_);
  auto tensor2_ix = gen.range(tensor2_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(handle_r_to_c(self[i].scalar_type(), grads[i]));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  if (needs_input_grad[/*tensor1*/1]) {  // tensor1
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(handle_r_to_c(tensor1[i].scalar_type(), grads[i] * (scalars[i] / tensor2[i]).conj()));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, tensor1_ix, grad_result);
  }
  if (needs_input_grad[/*tensor2*/2]) {  // tensor2
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(handle_r_to_c(tensor2[i][i].scalar_type(), -grads[i] * (scalars[i] * tensor1[i] / (tensor2[i] * tensor2[i])).conj()));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, tensor2_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachAddcdivBackward0ScalarList_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto tensor1_size_ = packed_args.unpack<size_t>();
  auto tensor2_size_ = packed_args.unpack<size_t>();
  auto scalars = packed_args.unpack<std::vector<at::Scalar>>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  auto tensor1 = packed_args.unpack<std::vector<Tensor>>();
  auto tensor2 = packed_args.unpack<std::vector<Tensor>>();
  return ForeachAddcdivBackward0ScalarList_apply_functional(variable_list(grads), needs_input_grad, self_size_, tensor1_size_, tensor2_size_, scalars, self, tensor1, tensor2);
#endif
}

variable_list ForeachAddcdivBackward0ScalarList::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  TORCH_CHECK(!tensor1_released_, ERR_BACKWARD_TWICE);
  TORCH_CHECK(!tensor2_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  auto tensor1 = unpack_list(tensor1_, nullptr);
  auto tensor2 = unpack_list(tensor2_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto tensor1_ix = gen.range(tensor1_size_);
  auto tensor2_ix = gen.range(tensor2_size_);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ tensor1_ix }),
    task_should_compute_output({ tensor2_ix }),
  };
  return ForeachAddcdivBackward0ScalarList_apply_functional(std::move(grads), needs_input_grad, self_size_, tensor1_size_, tensor2_size_, scalars, self, tensor1, tensor2);
}

void ForeachAddcdivBackward0ScalarList::compiled_args(CompiledNodeArgs& args) const {
    args.collect(scalars);
    args.collect(self_, false);
    args.collect(tensor1_, false);
    args.collect(tensor2_, false);
}
variable_list ForeachAddcdivBackward0ScalarList::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(scalars);
  saved.before(self_);
  saved.before(tensor1_);
  saved.before(tensor2_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<at::Scalar>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachAddcdivBackward0ScalarList_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  TORCH_CHECK(!tensor1_released_, ERR_BACKWARD_TWICE);
  TORCH_CHECK(!tensor2_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  auto tensor1 = unpack_list(tensor1_, nullptr);
  auto tensor2 = unpack_list(tensor2_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto tensor1_ix = gen.range(tensor1_size_);
  auto tensor2_ix = gen.range(tensor2_size_);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ tensor1_ix }),
    task_should_compute_output({ tensor2_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(tensor1_size_);
  packed_args.pack(tensor2_size_);
  packed_args.pack(scalars);
  packed_args.pack(self);
  packed_args.pack(tensor1);
  packed_args.pack(tensor2);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(scalars);
  saved.after(self_);
  saved.after(tensor1_);
  saved.after(tensor2_);
  return output_result;
#endif
}

static variable_list ForeachAddcmulBackward0Scalar_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, size_t self_size_, size_t tensor1_size_, size_t tensor2_size_, std::vector<Tensor>& self, std::vector<Tensor>& tensor1, std::vector<Tensor>& tensor2, at::Scalar& value)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto tensor1_ix = gen.range(tensor1_size_);
  auto tensor2_ix = gen.range(tensor2_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(handle_r_to_c(self[i].scalar_type(), grads[i]));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  if (needs_input_grad[/*tensor1*/1]) {  // tensor1
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(handle_r_to_c(tensor1[i].scalar_type(), grads[i] * (tensor2[i] * value).conj()));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, tensor1_ix, grad_result);
  }
  if (needs_input_grad[/*tensor2*/2]) {  // tensor2
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(handle_r_to_c(tensor2[i].scalar_type(), grads[i] * (tensor1[i] * value).conj()));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, tensor2_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachAddcmulBackward0Scalar_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto tensor1_size_ = packed_args.unpack<size_t>();
  auto tensor2_size_ = packed_args.unpack<size_t>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  auto tensor1 = packed_args.unpack<std::vector<Tensor>>();
  auto tensor2 = packed_args.unpack<std::vector<Tensor>>();
  auto value = packed_args.unpack<at::Scalar>();
  return ForeachAddcmulBackward0Scalar_apply_functional(variable_list(grads), needs_input_grad, self_size_, tensor1_size_, tensor2_size_, self, tensor1, tensor2, value);
#endif
}

variable_list ForeachAddcmulBackward0Scalar::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  TORCH_CHECK(!tensor1_released_, ERR_BACKWARD_TWICE);
  TORCH_CHECK(!tensor2_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  auto tensor1 = unpack_list(tensor1_, nullptr);
  auto tensor2 = unpack_list(tensor2_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto tensor1_ix = gen.range(tensor1_size_);
  auto tensor2_ix = gen.range(tensor2_size_);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ tensor1_ix }),
    task_should_compute_output({ tensor2_ix }),
  };
  return ForeachAddcmulBackward0Scalar_apply_functional(std::move(grads), needs_input_grad, self_size_, tensor1_size_, tensor2_size_, self, tensor1, tensor2, value);
}

void ForeachAddcmulBackward0Scalar::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
    args.collect(tensor1_, false);
    args.collect(tensor2_, false);
    args.collect(value);
}
variable_list ForeachAddcmulBackward0Scalar::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);
  saved.before(tensor1_);
  saved.before(tensor2_);
  saved.before(value);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachAddcmulBackward0Scalar_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  TORCH_CHECK(!tensor1_released_, ERR_BACKWARD_TWICE);
  TORCH_CHECK(!tensor2_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  auto tensor1 = unpack_list(tensor1_, nullptr);
  auto tensor2 = unpack_list(tensor2_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto tensor1_ix = gen.range(tensor1_size_);
  auto tensor2_ix = gen.range(tensor2_size_);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ tensor1_ix }),
    task_should_compute_output({ tensor2_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(tensor1_size_);
  packed_args.pack(tensor2_size_);
  packed_args.pack(self);
  packed_args.pack(tensor1);
  packed_args.pack(tensor2);
  packed_args.pack(value);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  saved.after(tensor1_);
  saved.after(tensor2_);
  saved.after(value);
  return output_result;
#endif
}

static variable_list ForeachAddcmulBackward0ScalarList_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, size_t self_size_, size_t tensor1_size_, size_t tensor2_size_, std::vector<at::Scalar>& scalars, std::vector<Tensor>& self, std::vector<Tensor>& tensor1, std::vector<Tensor>& tensor2)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto tensor1_ix = gen.range(tensor1_size_);
  auto tensor2_ix = gen.range(tensor2_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(handle_r_to_c(self[i].scalar_type(), grads[i]));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  if (needs_input_grad[/*tensor1*/1]) {  // tensor1
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(handle_r_to_c(tensor1[i].scalar_type(), grads[i] * (tensor2[i] * scalars[i]).conj()));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, tensor1_ix, grad_result);
  }
  if (needs_input_grad[/*tensor2*/2]) {  // tensor2
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(handle_r_to_c(tensor2[i].scalar_type(), grads[i] * (tensor1[i] * scalars[i]).conj()));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, tensor2_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachAddcmulBackward0ScalarList_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto tensor1_size_ = packed_args.unpack<size_t>();
  auto tensor2_size_ = packed_args.unpack<size_t>();
  auto scalars = packed_args.unpack<std::vector<at::Scalar>>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  auto tensor1 = packed_args.unpack<std::vector<Tensor>>();
  auto tensor2 = packed_args.unpack<std::vector<Tensor>>();
  return ForeachAddcmulBackward0ScalarList_apply_functional(variable_list(grads), needs_input_grad, self_size_, tensor1_size_, tensor2_size_, scalars, self, tensor1, tensor2);
#endif
}

variable_list ForeachAddcmulBackward0ScalarList::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  TORCH_CHECK(!tensor1_released_, ERR_BACKWARD_TWICE);
  TORCH_CHECK(!tensor2_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  auto tensor1 = unpack_list(tensor1_, nullptr);
  auto tensor2 = unpack_list(tensor2_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto tensor1_ix = gen.range(tensor1_size_);
  auto tensor2_ix = gen.range(tensor2_size_);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ tensor1_ix }),
    task_should_compute_output({ tensor2_ix }),
  };
  return ForeachAddcmulBackward0ScalarList_apply_functional(std::move(grads), needs_input_grad, self_size_, tensor1_size_, tensor2_size_, scalars, self, tensor1, tensor2);
}

void ForeachAddcmulBackward0ScalarList::compiled_args(CompiledNodeArgs& args) const {
    args.collect(scalars);
    args.collect(self_, false);
    args.collect(tensor1_, false);
    args.collect(tensor2_, false);
}
variable_list ForeachAddcmulBackward0ScalarList::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(scalars);
  saved.before(self_);
  saved.before(tensor1_);
  saved.before(tensor2_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<at::Scalar>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachAddcmulBackward0ScalarList_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  TORCH_CHECK(!tensor1_released_, ERR_BACKWARD_TWICE);
  TORCH_CHECK(!tensor2_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  auto tensor1 = unpack_list(tensor1_, nullptr);
  auto tensor2 = unpack_list(tensor2_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto tensor1_ix = gen.range(tensor1_size_);
  auto tensor2_ix = gen.range(tensor2_size_);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ tensor1_ix }),
    task_should_compute_output({ tensor2_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(tensor1_size_);
  packed_args.pack(tensor2_size_);
  packed_args.pack(scalars);
  packed_args.pack(self);
  packed_args.pack(tensor1);
  packed_args.pack(tensor2);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(scalars);
  saved.after(self_);
  saved.after(tensor1_);
  saved.after(tensor2_);
  return output_result;
#endif
}

static variable_list ForeachAsinBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t self_size_, std::vector<Tensor>& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(grads[i] * (-self[i] * self[i] + 1).rsqrt().conj());
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachAsinBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  return ForeachAsinBackward0_apply_functional(variable_list(grads), needs_input_grad, self_size_, self);
#endif
}

variable_list ForeachAsinBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ForeachAsinBackward0_apply_functional(std::move(grads), needs_input_grad, self_size_, self);
}

void ForeachAsinBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list ForeachAsinBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachAsinBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list ForeachAtanBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t self_size_, std::vector<Tensor>& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(grads[i] / (self[i] * self[i] + 1).conj());
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachAtanBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  return ForeachAtanBackward0_apply_functional(variable_list(grads), needs_input_grad, self_size_, self);
#endif
}

variable_list ForeachAtanBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ForeachAtanBackward0_apply_functional(std::move(grads), needs_input_grad, self_size_, self);
}

void ForeachAtanBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list ForeachAtanBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachAtanBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list ForeachCeilBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t self_size_)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(zeros_like(grads[i]));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachCeilBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_size_ = packed_args.unpack<size_t>();
  return ForeachCeilBackward0_apply_functional(variable_list(grads), needs_input_grad, self_size_);
#endif
}

variable_list ForeachCeilBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ForeachCeilBackward0_apply_functional(std::move(grads), needs_input_grad, self_size_);
}

void ForeachCeilBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list ForeachCeilBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachCeilBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list ForeachClampMaxBackward0Scalar_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t self_size_, at::Scalar& scalar, std::vector<Tensor>& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(where(self[i] <= scalar, grads[i], at::scalar_tensor(0., grads[i].options())));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachClampMaxBackward0Scalar_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto scalar = packed_args.unpack<at::Scalar>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  return ForeachClampMaxBackward0Scalar_apply_functional(variable_list(grads), needs_input_grad, self_size_, scalar, self);
#endif
}

variable_list ForeachClampMaxBackward0Scalar::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ForeachClampMaxBackward0Scalar_apply_functional(std::move(grads), needs_input_grad, self_size_, scalar, self);
}

void ForeachClampMaxBackward0Scalar::compiled_args(CompiledNodeArgs& args) const {
    args.collect(scalar);
    args.collect(self_, false);
}
variable_list ForeachClampMaxBackward0Scalar::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(scalar);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachClampMaxBackward0Scalar_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(scalar);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(scalar);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list ForeachClampMaxBackward1List_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, size_t self_size_, size_t other_size_, std::vector<Tensor>& other, std::vector<Tensor>& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto other_ix = gen.range(other_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*other*/1]) {  // other
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(where(self[i] > other[i], grads[i], at::scalar_tensor(0., grads[i].options())));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, other_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(where(self[i] <= other[i], grads[i], at::scalar_tensor(0., grads[i].options())));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachClampMaxBackward1List_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto other_size_ = packed_args.unpack<size_t>();
  auto other = packed_args.unpack<std::vector<Tensor>>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  return ForeachClampMaxBackward1List_apply_functional(variable_list(grads), needs_input_grad, self_size_, other_size_, other, self);
#endif
}

variable_list ForeachClampMaxBackward1List::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!other_released_, ERR_BACKWARD_TWICE);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto other = unpack_list(other_, nullptr);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto other_ix = gen.range(other_size_);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  return ForeachClampMaxBackward1List_apply_functional(std::move(grads), needs_input_grad, self_size_, other_size_, other, self);
}

void ForeachClampMaxBackward1List::compiled_args(CompiledNodeArgs& args) const {
    args.collect(other_, false);
    args.collect(self_, false);
}
variable_list ForeachClampMaxBackward1List::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(other_);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachClampMaxBackward1List_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!other_released_, ERR_BACKWARD_TWICE);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto other = unpack_list(other_, nullptr);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto other_ix = gen.range(other_size_);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(other_size_);
  packed_args.pack(other);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(other_);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list ForeachClampMaxBackward0ScalarList_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t self_size_, std::vector<at::Scalar>& scalars, std::vector<Tensor>& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(where(self[i] <= scalars[i], grads[i], at::scalar_tensor(0., grads[i].options())));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachClampMaxBackward0ScalarList_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto scalars = packed_args.unpack<std::vector<at::Scalar>>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  return ForeachClampMaxBackward0ScalarList_apply_functional(variable_list(grads), needs_input_grad, self_size_, scalars, self);
#endif
}

variable_list ForeachClampMaxBackward0ScalarList::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ForeachClampMaxBackward0ScalarList_apply_functional(std::move(grads), needs_input_grad, self_size_, scalars, self);
}

void ForeachClampMaxBackward0ScalarList::compiled_args(CompiledNodeArgs& args) const {
    args.collect(scalars);
    args.collect(self_, false);
}
variable_list ForeachClampMaxBackward0ScalarList::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(scalars);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<at::Scalar>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachClampMaxBackward0ScalarList_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(scalars);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(scalars);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list ForeachClampMinBackward0Scalar_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t self_size_, at::Scalar& scalar, std::vector<Tensor>& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(where(self[i] >= scalar, grads[i], at::scalar_tensor(0., grads[i].options())));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachClampMinBackward0Scalar_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto scalar = packed_args.unpack<at::Scalar>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  return ForeachClampMinBackward0Scalar_apply_functional(variable_list(grads), needs_input_grad, self_size_, scalar, self);
#endif
}

variable_list ForeachClampMinBackward0Scalar::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ForeachClampMinBackward0Scalar_apply_functional(std::move(grads), needs_input_grad, self_size_, scalar, self);
}

void ForeachClampMinBackward0Scalar::compiled_args(CompiledNodeArgs& args) const {
    args.collect(scalar);
    args.collect(self_, false);
}
variable_list ForeachClampMinBackward0Scalar::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(scalar);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachClampMinBackward0Scalar_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(scalar);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(scalar);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list ForeachClampMinBackward1List_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, size_t self_size_, size_t other_size_, std::vector<Tensor>& other, std::vector<Tensor>& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto other_ix = gen.range(other_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*other*/1]) {  // other
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(where(self[i] < other[i], grads[i], at::scalar_tensor(0., grads[i].options())));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, other_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(where(self[i] >= other[i], grads[i], at::scalar_tensor(0., grads[i].options())));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachClampMinBackward1List_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto other_size_ = packed_args.unpack<size_t>();
  auto other = packed_args.unpack<std::vector<Tensor>>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  return ForeachClampMinBackward1List_apply_functional(variable_list(grads), needs_input_grad, self_size_, other_size_, other, self);
#endif
}

variable_list ForeachClampMinBackward1List::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!other_released_, ERR_BACKWARD_TWICE);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto other = unpack_list(other_, nullptr);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto other_ix = gen.range(other_size_);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  return ForeachClampMinBackward1List_apply_functional(std::move(grads), needs_input_grad, self_size_, other_size_, other, self);
}

void ForeachClampMinBackward1List::compiled_args(CompiledNodeArgs& args) const {
    args.collect(other_, false);
    args.collect(self_, false);
}
variable_list ForeachClampMinBackward1List::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(other_);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachClampMinBackward1List_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!other_released_, ERR_BACKWARD_TWICE);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto other = unpack_list(other_, nullptr);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto other_ix = gen.range(other_size_);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(other_size_);
  packed_args.pack(other);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(other_);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list ForeachClampMinBackward0ScalarList_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t self_size_, std::vector<at::Scalar>& scalars, std::vector<Tensor>& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(where(self[i] >= scalars[i], grads[i], at::scalar_tensor(0., grads[i].options())));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachClampMinBackward0ScalarList_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto scalars = packed_args.unpack<std::vector<at::Scalar>>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  return ForeachClampMinBackward0ScalarList_apply_functional(variable_list(grads), needs_input_grad, self_size_, scalars, self);
#endif
}

variable_list ForeachClampMinBackward0ScalarList::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ForeachClampMinBackward0ScalarList_apply_functional(std::move(grads), needs_input_grad, self_size_, scalars, self);
}

void ForeachClampMinBackward0ScalarList::compiled_args(CompiledNodeArgs& args) const {
    args.collect(scalars);
    args.collect(self_, false);
}
variable_list ForeachClampMinBackward0ScalarList::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(scalars);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<at::Scalar>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachClampMinBackward0ScalarList_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(scalars);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(scalars);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list ForeachCosBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t self_size_, std::vector<Tensor>& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(grads[i] * -self[i].sin().conj());
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachCosBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  return ForeachCosBackward0_apply_functional(variable_list(grads), needs_input_grad, self_size_, self);
#endif
}

variable_list ForeachCosBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ForeachCosBackward0_apply_functional(std::move(grads), needs_input_grad, self_size_, self);
}

void ForeachCosBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list ForeachCosBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachCosBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list ForeachCoshBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t self_size_, std::vector<Tensor>& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(grads[i] * self[i].sinh().conj());
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachCoshBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  return ForeachCoshBackward0_apply_functional(variable_list(grads), needs_input_grad, self_size_, self);
#endif
}

variable_list ForeachCoshBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ForeachCoshBackward0_apply_functional(std::move(grads), needs_input_grad, self_size_, self);
}

void ForeachCoshBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list ForeachCoshBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachCoshBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list ForeachDivBackward1Scalar_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t self_size_, at::Scalar& scalar, std::vector<Tensor>& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(div_tensor_self_backward(grads[i], scalar, self[i].scalar_type()));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachDivBackward1Scalar_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto scalar = packed_args.unpack<at::Scalar>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  return ForeachDivBackward1Scalar_apply_functional(variable_list(grads), needs_input_grad, self_size_, scalar, self);
#endif
}

variable_list ForeachDivBackward1Scalar::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ForeachDivBackward1Scalar_apply_functional(std::move(grads), needs_input_grad, self_size_, scalar, self);
}

void ForeachDivBackward1Scalar::compiled_args(CompiledNodeArgs& args) const {
    args.collect(scalar);
    args.collect(self_, false);
}
variable_list ForeachDivBackward1Scalar::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(scalar);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachDivBackward1Scalar_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(scalar);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(scalar);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list ForeachDivBackward1ScalarList_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t self_size_, std::vector<at::Scalar>& scalars, std::vector<Tensor>& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(div_tensor_self_backward(grads[i], scalars[i], self[i].scalar_type()));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachDivBackward1ScalarList_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto scalars = packed_args.unpack<std::vector<at::Scalar>>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  return ForeachDivBackward1ScalarList_apply_functional(variable_list(grads), needs_input_grad, self_size_, scalars, self);
#endif
}

variable_list ForeachDivBackward1ScalarList::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ForeachDivBackward1ScalarList_apply_functional(std::move(grads), needs_input_grad, self_size_, scalars, self);
}

void ForeachDivBackward1ScalarList::compiled_args(CompiledNodeArgs& args) const {
    args.collect(scalars);
    args.collect(self_, false);
}
variable_list ForeachDivBackward1ScalarList::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(scalars);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<at::Scalar>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachDivBackward1ScalarList_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(scalars);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(scalars);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list ForeachDivBackward0Tensor_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, size_t self_size_, Tensor& other, std::vector<Tensor>& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto other_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*other*/1]) {  // other
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(any_grad_defined ? (div_tensor_other_backward(grads[i], self[i], other)) : Tensor());
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, other_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(div_tensor_self_backward(grads[i], other, self[i].scalar_type()));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachDivBackward0Tensor_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto other = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  return ForeachDivBackward0Tensor_apply_functional(variable_list(grads), needs_input_grad, self_size_, other, self);
#endif
}

variable_list ForeachDivBackward0Tensor::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto other = other_.unpack();
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  return ForeachDivBackward0Tensor_apply_functional(std::move(grads), needs_input_grad, self_size_, other, self);
}

void ForeachDivBackward0Tensor::compiled_args(CompiledNodeArgs& args) const {
    args.collect(other_, false);
    args.collect(self_, false);
}
variable_list ForeachDivBackward0Tensor::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(other_);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachDivBackward0Tensor_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto other = other_.unpack();
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(other);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(other_);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list ForeachErfBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t self_size_, std::vector<Tensor>& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(2.0 / sqrt(M_PI) * exp(-(self[i].pow(2))) * grads[i]);
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachErfBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  return ForeachErfBackward0_apply_functional(variable_list(grads), needs_input_grad, self_size_, self);
#endif
}

variable_list ForeachErfBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ForeachErfBackward0_apply_functional(std::move(grads), needs_input_grad, self_size_, self);
}

void ForeachErfBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list ForeachErfBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachErfBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list ForeachErfcBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t self_size_, std::vector<Tensor>& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(-2.0 / sqrt(M_PI) * exp(-(self[i].pow(2))) * grads[i]);
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachErfcBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  return ForeachErfcBackward0_apply_functional(variable_list(grads), needs_input_grad, self_size_, self);
#endif
}

variable_list ForeachErfcBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ForeachErfcBackward0_apply_functional(std::move(grads), needs_input_grad, self_size_, self);
}

void ForeachErfcBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list ForeachErfcBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachErfcBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list ForeachExpBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t self_size_, std::vector<Tensor>& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(grads[i] * result[i].conj());
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachExpBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto result = packed_args.unpack<std::vector<Tensor>>();
  return ForeachExpBackward0_apply_functional(variable_list(grads), needs_input_grad, self_size_, result);
#endif
}

variable_list ForeachExpBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!result_released_, ERR_BACKWARD_TWICE);
  auto result = unpack_list(result_, shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ForeachExpBackward0_apply_functional(std::move(grads), needs_input_grad, self_size_, result);
}

void ForeachExpBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(result_, true);
}
variable_list ForeachExpBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachExpBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!result_released_, ERR_BACKWARD_TWICE);
  auto result = unpack_list(result_, shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(result_);
  return output_result;
#endif
}

static variable_list ForeachExpm1Backward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t self_size_, std::vector<Tensor>& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(grads[i] * (result[i].conj() + 1));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachExpm1Backward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto result = packed_args.unpack<std::vector<Tensor>>();
  return ForeachExpm1Backward0_apply_functional(variable_list(grads), needs_input_grad, self_size_, result);
#endif
}

variable_list ForeachExpm1Backward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!result_released_, ERR_BACKWARD_TWICE);
  auto result = unpack_list(result_, shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ForeachExpm1Backward0_apply_functional(std::move(grads), needs_input_grad, self_size_, result);
}

void ForeachExpm1Backward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(result_, true);
}
variable_list ForeachExpm1Backward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachExpm1Backward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!result_released_, ERR_BACKWARD_TWICE);
  auto result = unpack_list(result_, shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(result_);
  return output_result;
#endif
}

static variable_list ForeachFloorBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t self_size_)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(zeros_like(grads[i]));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachFloorBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_size_ = packed_args.unpack<size_t>();
  return ForeachFloorBackward0_apply_functional(variable_list(grads), needs_input_grad, self_size_);
#endif
}

variable_list ForeachFloorBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ForeachFloorBackward0_apply_functional(std::move(grads), needs_input_grad, self_size_);
}

void ForeachFloorBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list ForeachFloorBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachFloorBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list ForeachFracBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t self_size_)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(grads[i]);
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachFracBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_size_ = packed_args.unpack<size_t>();
  return ForeachFracBackward0_apply_functional(variable_list(grads), needs_input_grad, self_size_);
#endif
}

variable_list ForeachFracBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ForeachFracBackward0_apply_functional(std::move(grads), needs_input_grad, self_size_);
}

void ForeachFracBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list ForeachFracBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachFracBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list ForeachLerpBackward1List_apply_functional(
  variable_list&& grads,
  std::array<bool,3> needs_input_grad, size_t self_size_, size_t tensors1_size_, size_t weights_size_, std::vector<Tensor>& self, std::vector<Tensor>& tensors1, std::vector<Tensor>& weights)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto tensors1_ix = gen.range(tensors1_size_);
  auto weights_ix = gen.range(weights_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*tensors1*/1]) {  // tensors1
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(grads[i] * weights[i].conj());
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, tensors1_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(grads[i] * (1 - weights[i]).conj());
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  if (needs_input_grad[/*weights*/2]) {  // weights
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(grads[i] * (tensors1[i] - self[i]).conj());
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, weights_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachLerpBackward1List_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 3>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto tensors1_size_ = packed_args.unpack<size_t>();
  auto weights_size_ = packed_args.unpack<size_t>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  auto tensors1 = packed_args.unpack<std::vector<Tensor>>();
  auto weights = packed_args.unpack<std::vector<Tensor>>();
  return ForeachLerpBackward1List_apply_functional(variable_list(grads), needs_input_grad, self_size_, tensors1_size_, weights_size_, self, tensors1, weights);
#endif
}

variable_list ForeachLerpBackward1List::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  TORCH_CHECK(!tensors1_released_, ERR_BACKWARD_TWICE);
  TORCH_CHECK(!weights_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  auto tensors1 = unpack_list(tensors1_, nullptr);
  auto weights = unpack_list(weights_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto tensors1_ix = gen.range(tensors1_size_);
  auto weights_ix = gen.range(weights_size_);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ tensors1_ix }),
    task_should_compute_output({ weights_ix }),
  };
  return ForeachLerpBackward1List_apply_functional(std::move(grads), needs_input_grad, self_size_, tensors1_size_, weights_size_, self, tensors1, weights);
}

void ForeachLerpBackward1List::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
    args.collect(tensors1_, false);
    args.collect(weights_, false);
}
variable_list ForeachLerpBackward1List::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);
  saved.before(tensors1_);
  saved.before(weights_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 3>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachLerpBackward1List_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  TORCH_CHECK(!tensors1_released_, ERR_BACKWARD_TWICE);
  TORCH_CHECK(!weights_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  auto tensors1 = unpack_list(tensors1_, nullptr);
  auto weights = unpack_list(weights_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto tensors1_ix = gen.range(tensors1_size_);
  auto weights_ix = gen.range(weights_size_);
  auto needs_input_grad = std::array<bool, 3>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ tensors1_ix }),
    task_should_compute_output({ weights_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(tensors1_size_);
  packed_args.pack(weights_size_);
  packed_args.pack(self);
  packed_args.pack(tensors1);
  packed_args.pack(weights);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  saved.after(tensors1_);
  saved.after(weights_);
  return output_result;
#endif
}

static variable_list ForeachLerpBackward0Scalar_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, size_t self_size_, size_t tensors1_size_, at::Scalar& weight)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto tensors1_ix = gen.range(tensors1_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*tensors1*/1]) {  // tensors1
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(grads[i] * weight.conj());
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, tensors1_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(weight.isComplex() ? grads[i] * (1 - weight.conj().toComplexDouble()) : grads[i] * (1 - weight.toDouble()));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachLerpBackward0Scalar_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto tensors1_size_ = packed_args.unpack<size_t>();
  auto weight = packed_args.unpack<at::Scalar>();
  return ForeachLerpBackward0Scalar_apply_functional(variable_list(grads), needs_input_grad, self_size_, tensors1_size_, weight);
#endif
}

variable_list ForeachLerpBackward0Scalar::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto tensors1_ix = gen.range(tensors1_size_);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ tensors1_ix }),
  };
  return ForeachLerpBackward0Scalar_apply_functional(std::move(grads), needs_input_grad, self_size_, tensors1_size_, weight);
}

void ForeachLerpBackward0Scalar::compiled_args(CompiledNodeArgs& args) const {
    args.collect(weight);
}
variable_list ForeachLerpBackward0Scalar::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(weight);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachLerpBackward0Scalar_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto tensors1_ix = gen.range(tensors1_size_);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ tensors1_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(tensors1_size_);
  packed_args.pack(weight);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(weight);
  return output_result;
#endif
}

static variable_list ForeachLerpBackward0ScalarList_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, size_t self_size_, size_t tensors1_size_, std::vector<at::Scalar>& weight)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto tensors1_ix = gen.range(tensors1_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*tensors1*/1]) {  // tensors1
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(grads[i] * weight[i].conj());
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, tensors1_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(weight[i].isComplex() ? grads[i] * (1 - weight[i].conj().toComplexDouble()) : grads[i] * (1 - weight[i].toDouble()));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachLerpBackward0ScalarList_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto tensors1_size_ = packed_args.unpack<size_t>();
  auto weight = packed_args.unpack<std::vector<at::Scalar>>();
  return ForeachLerpBackward0ScalarList_apply_functional(variable_list(grads), needs_input_grad, self_size_, tensors1_size_, weight);
#endif
}

variable_list ForeachLerpBackward0ScalarList::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);


  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto tensors1_ix = gen.range(tensors1_size_);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ tensors1_ix }),
  };
  return ForeachLerpBackward0ScalarList_apply_functional(std::move(grads), needs_input_grad, self_size_, tensors1_size_, weight);
}

void ForeachLerpBackward0ScalarList::compiled_args(CompiledNodeArgs& args) const {
    args.collect(weight);
}
variable_list ForeachLerpBackward0ScalarList::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(weight);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<at::Scalar>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachLerpBackward0ScalarList_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto tensors1_ix = gen.range(tensors1_size_);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ tensors1_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(tensors1_size_);
  packed_args.pack(weight);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(weight);
  return output_result;
#endif
}

static variable_list ForeachLgammaBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t self_size_, std::vector<Tensor>& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(grads[i] * digamma(self[i]));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachLgammaBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  return ForeachLgammaBackward0_apply_functional(variable_list(grads), needs_input_grad, self_size_, self);
#endif
}

variable_list ForeachLgammaBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ForeachLgammaBackward0_apply_functional(std::move(grads), needs_input_grad, self_size_, self);
}

void ForeachLgammaBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list ForeachLgammaBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachLgammaBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list ForeachLogBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t self_size_, std::vector<Tensor>& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(grads[i].div(self[i].conj()));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachLogBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  return ForeachLogBackward0_apply_functional(variable_list(grads), needs_input_grad, self_size_, self);
#endif
}

variable_list ForeachLogBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ForeachLogBackward0_apply_functional(std::move(grads), needs_input_grad, self_size_, self);
}

void ForeachLogBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list ForeachLogBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachLogBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list ForeachLog10Backward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t self_size_, std::vector<Tensor>& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(grads[i] / (self[i].conj() * 2.3025850929940456));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachLog10Backward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  return ForeachLog10Backward0_apply_functional(variable_list(grads), needs_input_grad, self_size_, self);
#endif
}

variable_list ForeachLog10Backward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ForeachLog10Backward0_apply_functional(std::move(grads), needs_input_grad, self_size_, self);
}

void ForeachLog10Backward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list ForeachLog10Backward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachLog10Backward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list ForeachLog1PBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t self_size_, std::vector<Tensor>& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(log1p_backward(grads[i], self[i]));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachLog1PBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  return ForeachLog1PBackward0_apply_functional(variable_list(grads), needs_input_grad, self_size_, self);
#endif
}

variable_list ForeachLog1PBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ForeachLog1PBackward0_apply_functional(std::move(grads), needs_input_grad, self_size_, self);
}

void ForeachLog1PBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list ForeachLog1PBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachLog1PBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list ForeachLog2Backward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t self_size_, std::vector<Tensor>& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(grads[i] / (self[i].conj() * 0.6931471805599453));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachLog2Backward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  return ForeachLog2Backward0_apply_functional(variable_list(grads), needs_input_grad, self_size_, self);
#endif
}

variable_list ForeachLog2Backward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ForeachLog2Backward0_apply_functional(std::move(grads), needs_input_grad, self_size_, self);
}

void ForeachLog2Backward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list ForeachLog2Backward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachLog2Backward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list ForeachMaxBackward1_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t self_size_, std::vector<Tensor>& self, std::vector<Tensor>& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(evenly_distribute_backward(grads[i], self[i], result[i]));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachMaxBackward1_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  auto result = packed_args.unpack<std::vector<Tensor>>();
  return ForeachMaxBackward1_apply_functional(variable_list(grads), needs_input_grad, self_size_, self, result);
#endif
}

variable_list ForeachMaxBackward1::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  TORCH_CHECK(!result_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  auto result = unpack_list(result_, shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ForeachMaxBackward1_apply_functional(std::move(grads), needs_input_grad, self_size_, self, result);
}

void ForeachMaxBackward1::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
    args.collect(result_, true);
}
variable_list ForeachMaxBackward1::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachMaxBackward1_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  TORCH_CHECK(!result_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  auto result = unpack_list(result_, shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(self);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  saved.after(result_);
  return output_result;
#endif
}

static variable_list ForeachMaximumBackward0List_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, size_t self_size_, size_t other_size_, std::vector<Tensor>& other, std::vector<Tensor>& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto other_ix = gen.range(other_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*other*/1]) {  // other
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(at::where(self[i] == other[i], grads[i] / 2, grads[i]).masked_fill_(self[i] > other[i], 0));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, other_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(at::where(self[i] == other[i], grads[i] / 2, grads[i]).masked_fill_(self[i] < other[i], 0));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachMaximumBackward0List_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto other_size_ = packed_args.unpack<size_t>();
  auto other = packed_args.unpack<std::vector<Tensor>>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  return ForeachMaximumBackward0List_apply_functional(variable_list(grads), needs_input_grad, self_size_, other_size_, other, self);
#endif
}

variable_list ForeachMaximumBackward0List::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!other_released_, ERR_BACKWARD_TWICE);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto other = unpack_list(other_, nullptr);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto other_ix = gen.range(other_size_);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  return ForeachMaximumBackward0List_apply_functional(std::move(grads), needs_input_grad, self_size_, other_size_, other, self);
}

void ForeachMaximumBackward0List::compiled_args(CompiledNodeArgs& args) const {
    args.collect(other_, false);
    args.collect(self_, false);
}
variable_list ForeachMaximumBackward0List::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(other_);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachMaximumBackward0List_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!other_released_, ERR_BACKWARD_TWICE);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto other = unpack_list(other_, nullptr);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto other_ix = gen.range(other_size_);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(other_size_);
  packed_args.pack(other);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(other_);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list ForeachMinimumBackward0List_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, size_t self_size_, size_t other_size_, std::vector<Tensor>& other, std::vector<Tensor>& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto other_ix = gen.range(other_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*other*/1]) {  // other
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(at::where(self[i] == other[i], grads[i] / 2, grads[i]).masked_fill_(self[i] < other[i], 0));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, other_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(at::where(self[i] == other[i], grads[i] / 2, grads[i]).masked_fill_(self[i] > other[i], 0));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachMinimumBackward0List_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto other_size_ = packed_args.unpack<size_t>();
  auto other = packed_args.unpack<std::vector<Tensor>>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  return ForeachMinimumBackward0List_apply_functional(variable_list(grads), needs_input_grad, self_size_, other_size_, other, self);
#endif
}

variable_list ForeachMinimumBackward0List::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!other_released_, ERR_BACKWARD_TWICE);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto other = unpack_list(other_, nullptr);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto other_ix = gen.range(other_size_);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  return ForeachMinimumBackward0List_apply_functional(std::move(grads), needs_input_grad, self_size_, other_size_, other, self);
}

void ForeachMinimumBackward0List::compiled_args(CompiledNodeArgs& args) const {
    args.collect(other_, false);
    args.collect(self_, false);
}
variable_list ForeachMinimumBackward0List::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(other_);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachMinimumBackward0List_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!other_released_, ERR_BACKWARD_TWICE);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto other = unpack_list(other_, nullptr);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto other_ix = gen.range(other_size_);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(other_size_);
  packed_args.pack(other);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(other_);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list ForeachMulBackward1Scalar_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t self_size_, at::Scalar& scalar, std::vector<Tensor>& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(mul_tensor_backward(grads[i], scalar, self[i].scalar_type()));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachMulBackward1Scalar_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto scalar = packed_args.unpack<at::Scalar>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  return ForeachMulBackward1Scalar_apply_functional(variable_list(grads), needs_input_grad, self_size_, scalar, self);
#endif
}

variable_list ForeachMulBackward1Scalar::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ForeachMulBackward1Scalar_apply_functional(std::move(grads), needs_input_grad, self_size_, scalar, self);
}

void ForeachMulBackward1Scalar::compiled_args(CompiledNodeArgs& args) const {
    args.collect(scalar);
    args.collect(self_, false);
}
variable_list ForeachMulBackward1Scalar::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(scalar);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachMulBackward1Scalar_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(scalar);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(scalar);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list ForeachMulBackward0List_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, size_t self_size_, size_t other_size_, std::vector<Tensor>& other, std::vector<Tensor>& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto other_ix = gen.range(other_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*other*/1]) {  // other
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(mul_tensor_backward(grads[i], self[i], other[i].scalar_type()));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, other_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(mul_tensor_backward(grads[i], other[i], self[i].scalar_type()));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachMulBackward0List_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto other_size_ = packed_args.unpack<size_t>();
  auto other = packed_args.unpack<std::vector<Tensor>>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  return ForeachMulBackward0List_apply_functional(variable_list(grads), needs_input_grad, self_size_, other_size_, other, self);
#endif
}

variable_list ForeachMulBackward0List::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!other_released_, ERR_BACKWARD_TWICE);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto other = unpack_list(other_, nullptr);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto other_ix = gen.range(other_size_);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  return ForeachMulBackward0List_apply_functional(std::move(grads), needs_input_grad, self_size_, other_size_, other, self);
}

void ForeachMulBackward0List::compiled_args(CompiledNodeArgs& args) const {
    args.collect(other_, false);
    args.collect(self_, false);
}
variable_list ForeachMulBackward0List::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(other_);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachMulBackward0List_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!other_released_, ERR_BACKWARD_TWICE);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto other = unpack_list(other_, nullptr);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto other_ix = gen.range(other_size_);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(other_size_);
  packed_args.pack(other);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(other_);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list ForeachMulBackward1ScalarList_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t self_size_, std::vector<at::Scalar>& scalars, std::vector<Tensor>& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(mul_tensor_backward(grads[i], scalars[i], self[i].scalar_type()));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachMulBackward1ScalarList_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto scalars = packed_args.unpack<std::vector<at::Scalar>>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  return ForeachMulBackward1ScalarList_apply_functional(variable_list(grads), needs_input_grad, self_size_, scalars, self);
#endif
}

variable_list ForeachMulBackward1ScalarList::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ForeachMulBackward1ScalarList_apply_functional(std::move(grads), needs_input_grad, self_size_, scalars, self);
}

void ForeachMulBackward1ScalarList::compiled_args(CompiledNodeArgs& args) const {
    args.collect(scalars);
    args.collect(self_, false);
}
variable_list ForeachMulBackward1ScalarList::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(scalars);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<at::Scalar>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachMulBackward1ScalarList_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(scalars);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(scalars);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list ForeachMulBackward0Tensor_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, size_t self_size_, Tensor& other, std::vector<Tensor>& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto other_ix = gen.range(1);
  variable_list grad_inputs(gen.size());
  bool any_grad_defined = any_variable_defined(grads);
  if (needs_input_grad[/*other*/1]) {  // other
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(any_grad_defined ? (mul_tensor_backward(grads[i], self[i], other.scalar_type())) : Tensor());
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, other_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(mul_tensor_backward(grads[i], other, self[i].scalar_type()));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachMulBackward0Tensor_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto other = packed_args.unpack<Tensor>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  return ForeachMulBackward0Tensor_apply_functional(variable_list(grads), needs_input_grad, self_size_, other, self);
#endif
}

variable_list ForeachMulBackward0Tensor::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto other = other_.unpack();
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  return ForeachMulBackward0Tensor_apply_functional(std::move(grads), needs_input_grad, self_size_, other, self);
}

void ForeachMulBackward0Tensor::compiled_args(CompiledNodeArgs& args) const {
    args.collect(other_, false);
    args.collect(self_, false);
}
variable_list ForeachMulBackward0Tensor::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(other_);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<Tensor>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachMulBackward0Tensor_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto other = other_.unpack();
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto other_ix = gen.range(1);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(other);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(other_);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list ForeachNegBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t self_size_)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(grads[i].neg());
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachNegBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_size_ = packed_args.unpack<size_t>();
  return ForeachNegBackward0_apply_functional(variable_list(grads), needs_input_grad, self_size_);
#endif
}

variable_list ForeachNegBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ForeachNegBackward0_apply_functional(std::move(grads), needs_input_grad, self_size_);
}

void ForeachNegBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list ForeachNegBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachNegBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list ForeachPowBackward0Scalar_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t self_size_, at::Scalar& exponent, std::vector<Tensor>& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(pow_backward(grads[i], self[i], exponent));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachPowBackward0Scalar_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto exponent = packed_args.unpack<at::Scalar>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  return ForeachPowBackward0Scalar_apply_functional(variable_list(grads), needs_input_grad, self_size_, exponent, self);
#endif
}

variable_list ForeachPowBackward0Scalar::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ForeachPowBackward0Scalar_apply_functional(std::move(grads), needs_input_grad, self_size_, exponent, self);
}

void ForeachPowBackward0Scalar::compiled_args(CompiledNodeArgs& args) const {
    args.collect(exponent);
    args.collect(self_, false);
}
variable_list ForeachPowBackward0Scalar::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(exponent);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachPowBackward0Scalar_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(exponent);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(exponent);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list ForeachReciprocalBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t self_size_, std::vector<Tensor>& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(-grads[i] * (result[i] * result[i]).conj());
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachReciprocalBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto result = packed_args.unpack<std::vector<Tensor>>();
  return ForeachReciprocalBackward0_apply_functional(variable_list(grads), needs_input_grad, self_size_, result);
#endif
}

variable_list ForeachReciprocalBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!result_released_, ERR_BACKWARD_TWICE);
  auto result = unpack_list(result_, shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ForeachReciprocalBackward0_apply_functional(std::move(grads), needs_input_grad, self_size_, result);
}

void ForeachReciprocalBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(result_, true);
}
variable_list ForeachReciprocalBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachReciprocalBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!result_released_, ERR_BACKWARD_TWICE);
  auto result = unpack_list(result_, shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(result_);
  return output_result;
#endif
}

static variable_list ForeachRoundBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t self_size_)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(zeros_like(grads[i]));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachRoundBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_size_ = packed_args.unpack<size_t>();
  return ForeachRoundBackward0_apply_functional(variable_list(grads), needs_input_grad, self_size_);
#endif
}

variable_list ForeachRoundBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ForeachRoundBackward0_apply_functional(std::move(grads), needs_input_grad, self_size_);
}

void ForeachRoundBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list ForeachRoundBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachRoundBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list ForeachRsqrtBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t self_size_, std::vector<Tensor>& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(-0.5 * grads[i] * result[i].pow(3).conj());
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachRsqrtBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto result = packed_args.unpack<std::vector<Tensor>>();
  return ForeachRsqrtBackward0_apply_functional(variable_list(grads), needs_input_grad, self_size_, result);
#endif
}

variable_list ForeachRsqrtBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!result_released_, ERR_BACKWARD_TWICE);
  auto result = unpack_list(result_, shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ForeachRsqrtBackward0_apply_functional(std::move(grads), needs_input_grad, self_size_, result);
}

void ForeachRsqrtBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(result_, true);
}
variable_list ForeachRsqrtBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachRsqrtBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!result_released_, ERR_BACKWARD_TWICE);
  auto result = unpack_list(result_, shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(result_);
  return output_result;
#endif
}

static variable_list ForeachSigmoidBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t self_size_, std::vector<Tensor>& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(sigmoid_backward(grads[i], result[i]));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachSigmoidBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto result = packed_args.unpack<std::vector<Tensor>>();
  return ForeachSigmoidBackward0_apply_functional(variable_list(grads), needs_input_grad, self_size_, result);
#endif
}

variable_list ForeachSigmoidBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!result_released_, ERR_BACKWARD_TWICE);
  auto result = unpack_list(result_, shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ForeachSigmoidBackward0_apply_functional(std::move(grads), needs_input_grad, self_size_, result);
}

void ForeachSigmoidBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(result_, true);
}
variable_list ForeachSigmoidBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachSigmoidBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!result_released_, ERR_BACKWARD_TWICE);
  auto result = unpack_list(result_, shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(result_);
  return output_result;
#endif
}

static variable_list ForeachSignBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t self_size_)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(zeros_like(grads[i]));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachSignBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_size_ = packed_args.unpack<size_t>();
  return ForeachSignBackward0_apply_functional(variable_list(grads), needs_input_grad, self_size_);
#endif
}

variable_list ForeachSignBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ForeachSignBackward0_apply_functional(std::move(grads), needs_input_grad, self_size_);
}

void ForeachSignBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list ForeachSignBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachSignBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

static variable_list ForeachSinBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t self_size_, std::vector<Tensor>& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(grads[i] * self[i].cos().conj());
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachSinBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  return ForeachSinBackward0_apply_functional(variable_list(grads), needs_input_grad, self_size_, self);
#endif
}

variable_list ForeachSinBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ForeachSinBackward0_apply_functional(std::move(grads), needs_input_grad, self_size_, self);
}

void ForeachSinBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list ForeachSinBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachSinBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list ForeachSinhBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t self_size_, std::vector<Tensor>& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(grads[i] * self[i].cosh().conj());
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachSinhBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  return ForeachSinhBackward0_apply_functional(variable_list(grads), needs_input_grad, self_size_, self);
#endif
}

variable_list ForeachSinhBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ForeachSinhBackward0_apply_functional(std::move(grads), needs_input_grad, self_size_, self);
}

void ForeachSinhBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list ForeachSinhBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachSinhBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list ForeachSqrtBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t self_size_, std::vector<Tensor>& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(grads[i] / (2 * result[i].conj()));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachSqrtBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto result = packed_args.unpack<std::vector<Tensor>>();
  return ForeachSqrtBackward0_apply_functional(variable_list(grads), needs_input_grad, self_size_, result);
#endif
}

variable_list ForeachSqrtBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!result_released_, ERR_BACKWARD_TWICE);
  auto result = unpack_list(result_, shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ForeachSqrtBackward0_apply_functional(std::move(grads), needs_input_grad, self_size_, result);
}

void ForeachSqrtBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(result_, true);
}
variable_list ForeachSqrtBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachSqrtBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!result_released_, ERR_BACKWARD_TWICE);
  auto result = unpack_list(result_, shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(result_);
  return output_result;
#endif
}

static variable_list ForeachSubBackward1Scalar_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t self_size_, std::vector<Tensor>& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(handle_r_to_c(self[i].scalar_type(), grads[i]));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachSubBackward1Scalar_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  return ForeachSubBackward1Scalar_apply_functional(variable_list(grads), needs_input_grad, self_size_, self);
#endif
}

variable_list ForeachSubBackward1Scalar::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ForeachSubBackward1Scalar_apply_functional(std::move(grads), needs_input_grad, self_size_, self);
}

void ForeachSubBackward1Scalar::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list ForeachSubBackward1Scalar::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachSubBackward1Scalar_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list ForeachSubBackward0List_apply_functional(
  variable_list&& grads,
  std::array<bool,2> needs_input_grad, size_t self_size_, size_t other_size_, at::Scalar& alpha, std::vector<Tensor>& other, std::vector<Tensor>& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto other_ix = gen.range(other_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*other*/1]) {  // other
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(handle_r_to_c(other[i].scalar_type(), maybe_multiply(-grads[i], alpha.conj())));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, other_ix, grad_result);
  }
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(handle_r_to_c(self[i].scalar_type(), grads[i]));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachSubBackward0List_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 2>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto other_size_ = packed_args.unpack<size_t>();
  auto alpha = packed_args.unpack<at::Scalar>();
  auto other = packed_args.unpack<std::vector<Tensor>>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  return ForeachSubBackward0List_apply_functional(variable_list(grads), needs_input_grad, self_size_, other_size_, alpha, other, self);
#endif
}

variable_list ForeachSubBackward0List::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!other_released_, ERR_BACKWARD_TWICE);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto other = unpack_list(other_, nullptr);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto other_ix = gen.range(other_size_);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  return ForeachSubBackward0List_apply_functional(std::move(grads), needs_input_grad, self_size_, other_size_, alpha, other, self);
}

void ForeachSubBackward0List::compiled_args(CompiledNodeArgs& args) const {
    args.collect(alpha);
    args.collect(other_, false);
    args.collect(self_, false);
}
variable_list ForeachSubBackward0List::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(alpha);
  saved.before(other_);
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 2>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<at::Scalar>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachSubBackward0List_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!other_released_, ERR_BACKWARD_TWICE);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto other = unpack_list(other_, nullptr);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto other_ix = gen.range(other_size_);
  auto needs_input_grad = std::array<bool, 2>{
    task_should_compute_output({ self_ix }),
    task_should_compute_output({ other_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(other_size_);
  packed_args.pack(alpha);
  packed_args.pack(other);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(alpha);
  saved.after(other_);
  saved.after(self_);
  return output_result;
#endif
}

static variable_list ForeachSubBackward1ScalarList_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t self_size_, std::vector<Tensor>& self)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(handle_r_to_c(self[i].scalar_type(), grads[i]));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachSubBackward1ScalarList_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto self = packed_args.unpack<std::vector<Tensor>>();
  return ForeachSubBackward1ScalarList_apply_functional(variable_list(grads), needs_input_grad, self_size_, self);
#endif
}

variable_list ForeachSubBackward1ScalarList::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ForeachSubBackward1ScalarList_apply_functional(std::move(grads), needs_input_grad, self_size_, self);
}

void ForeachSubBackward1ScalarList::compiled_args(CompiledNodeArgs& args) const {
    args.collect(self_, false);
}
variable_list ForeachSubBackward1ScalarList::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(self_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachSubBackward1ScalarList_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!self_released_, ERR_BACKWARD_TWICE);
  auto self = unpack_list(self_, nullptr);
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(self);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(self_);
  return output_result;
#endif
}

static variable_list ForeachTanBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t self_size_, std::vector<Tensor>& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(grads[i] * (1 + result[i].pow(2)).conj());
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachTanBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto result = packed_args.unpack<std::vector<Tensor>>();
  return ForeachTanBackward0_apply_functional(variable_list(grads), needs_input_grad, self_size_, result);
#endif
}

variable_list ForeachTanBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!result_released_, ERR_BACKWARD_TWICE);
  auto result = unpack_list(result_, shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ForeachTanBackward0_apply_functional(std::move(grads), needs_input_grad, self_size_, result);
}

void ForeachTanBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(result_, true);
}
variable_list ForeachTanBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachTanBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!result_released_, ERR_BACKWARD_TWICE);
  auto result = unpack_list(result_, shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(result_);
  return output_result;
#endif
}

static variable_list ForeachTanhBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t self_size_, std::vector<Tensor>& result)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(tanh_backward(grads[i], result[i]));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachTanhBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_size_ = packed_args.unpack<size_t>();
  auto result = packed_args.unpack<std::vector<Tensor>>();
  return ForeachTanhBackward0_apply_functional(variable_list(grads), needs_input_grad, self_size_, result);
#endif
}

variable_list ForeachTanhBackward0::apply(variable_list&& grads) {
  std::lock_guard<std::mutex> lock(mutex_);
  TORCH_CHECK(!result_released_, ERR_BACKWARD_TWICE);
  auto result = unpack_list(result_, shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ForeachTanhBackward0_apply_functional(std::move(grads), needs_input_grad, self_size_, result);
}

void ForeachTanhBackward0::compiled_args(CompiledNodeArgs& args) const {
    args.collect(result_, true);
}
variable_list ForeachTanhBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  saved.before(result_);

  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
      torch::dynamo::autograd::IValuePacker<std::vector<Tensor>>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachTanhBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  TORCH_CHECK(!result_released_, ERR_BACKWARD_TWICE);
  auto result = unpack_list(result_, shared_from_this());
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);
  packed_args.pack(result);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  saved.after(result_);
  return output_result;
#endif
}

static variable_list ForeachTruncBackward0_apply_functional(
  variable_list&& grads,
  std::array<bool,1> needs_input_grad, size_t self_size_)
{
  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  variable_list grad_inputs(gen.size());
  if (needs_input_grad[/*self*/0]) {  // self
    std::vector<Tensor> grad_result;
    grad_result.reserve(grads.size());
    for (const auto & i : c10::irange(grads.size())) {
      if (grads[i].defined()) {
        grad_result.emplace_back(zeros_like(grads[i]));
      } else {
        grad_result.emplace_back(Tensor());
      }
    }
    copy_range(grad_inputs, self_ix, grad_result);
  }
  return grad_inputs;
}
inline variable_list ForeachTruncBackward0_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, 1>>();
  auto self_size_ = packed_args.unpack<size_t>();
  return ForeachTruncBackward0_apply_functional(variable_list(grads), needs_input_grad, self_size_);
#endif
}

variable_list ForeachTruncBackward0::apply(variable_list&& grads) {



  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  return ForeachTruncBackward0_apply_functional(std::move(grads), needs_input_grad, self_size_);
}

void ForeachTruncBackward0::compiled_args(CompiledNodeArgs& args) const {

}
variable_list ForeachTruncBackward0::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else


  static bool called = false;
  if (!called) {
    called = true;
    std::vector<at::TypePtr> schema = {
      torch::dynamo::autograd::IValuePacker<std::array<bool, 1>>::packed_type(),
      torch::dynamo::autograd::IValuePacker<size_t>::packed_type(),
    };
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ForeachTruncBackward0_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;


  IndexRangeGenerator gen;
  auto self_ix = gen.range(self_size_);
  auto needs_input_grad = std::array<bool, 1>{
    task_should_compute_output({ self_ix }),
  };
  packed_args.pack(needs_input_grad);
  packed_args.pack(self_size_);

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());


  return output_result;
#endif
}

} // namespace torch::autograd::generated