// this file is generated by paddle/phi/api/yaml/generator/generate_op.py, do not edit.
#include "paddle/phi/core/compat/op_utils.h"
#include "paddle/utils/small_vector.h"

namespace phi {

KernelSignature Atan2OpArgumentMapping(const ArgumentMappingContext& ctx) {
  paddle::small_vector<const char*> inputs {"X1", "X2"};
  paddle::small_vector<const char*> attrs;
  paddle::small_vector<const char*> outputs {"Out"};
  KernelSignature sig("atan2", std::move(inputs), std::move(attrs), std::move(outputs));
  return sig;
}

/*
******************************************************************
NOTE: The following codes are for 'get_compat_kernel_signature.py'
All possible KernelSignatures returned by Atan2OpArgumentMapping:

return KernelSignature("atan2", {"X1", "X2"}, {}, {"Out"});
******************************************************************
*/

KernelSignature BernoulliOpArgumentMapping(const ArgumentMappingContext& ctx) {
  paddle::small_vector<const char*> inputs {"X"};
  paddle::small_vector<const char*> attrs;
  paddle::small_vector<const char*> outputs {"Out"};
  KernelSignature sig("bernoulli", std::move(inputs), std::move(attrs), std::move(outputs));
  return sig;
}

/*
******************************************************************
NOTE: The following codes are for 'get_compat_kernel_signature.py'
All possible KernelSignatures returned by BernoulliOpArgumentMapping:

return KernelSignature("bernoulli", {"X"}, {}, {"Out"});
******************************************************************
*/

KernelSignature CholeskyOpArgumentMapping(const ArgumentMappingContext& ctx) {
  paddle::small_vector<const char*> inputs {"X"};
  paddle::small_vector<const char*> attrs;
  attrs.emplace_back("upper");
  paddle::small_vector<const char*> outputs {"Out"};
  KernelSignature sig("cholesky", std::move(inputs), std::move(attrs), std::move(outputs));
  return sig;
}

/*
******************************************************************
NOTE: The following codes are for 'get_compat_kernel_signature.py'
All possible KernelSignatures returned by CholeskyOpArgumentMapping:

return KernelSignature("cholesky", {"X"}, {"upper"}, {"Out"});
******************************************************************
*/

KernelSignature CholeskySolveOpArgumentMapping(const ArgumentMappingContext& ctx) {
  paddle::small_vector<const char*> inputs {"X", "Y"};
  paddle::small_vector<const char*> attrs;
  attrs.emplace_back("upper");
  paddle::small_vector<const char*> outputs {"Out"};
  KernelSignature sig("cholesky_solve", std::move(inputs), std::move(attrs), std::move(outputs));
  return sig;
}

/*
******************************************************************
NOTE: The following codes are for 'get_compat_kernel_signature.py'
All possible KernelSignatures returned by CholeskySolveOpArgumentMapping:

return KernelSignature("cholesky_solve", {"X", "Y"}, {"upper"}, {"Out"});
******************************************************************
*/

KernelSignature CrossOpArgumentMapping(const ArgumentMappingContext& ctx) {
  paddle::small_vector<const char*> inputs {"X", "Y"};
  paddle::small_vector<const char*> attrs;
  attrs.emplace_back("dim");
  paddle::small_vector<const char*> outputs {"Out"};
  KernelSignature sig("cross", std::move(inputs), std::move(attrs), std::move(outputs));
  return sig;
}

/*
******************************************************************
NOTE: The following codes are for 'get_compat_kernel_signature.py'
All possible KernelSignatures returned by CrossOpArgumentMapping:

return KernelSignature("cross", {"X", "Y"}, {"dim"}, {"Out"});
******************************************************************
*/

KernelSignature DiagOpArgumentMapping(const ArgumentMappingContext& ctx) {
  paddle::small_vector<const char*> inputs {"X"};
  paddle::small_vector<const char*> attrs;
  attrs.emplace_back("offset");
  attrs.emplace_back("padding_value");
  paddle::small_vector<const char*> outputs {"Out"};
  KernelSignature sig("diag", std::move(inputs), std::move(attrs), std::move(outputs));
  return sig;
}

/*
******************************************************************
NOTE: The following codes are for 'get_compat_kernel_signature.py'
All possible KernelSignatures returned by DiagOpArgumentMapping:

return KernelSignature("diag", {"X"}, {"offset", "padding_value"}, {"Out"});
******************************************************************
*/

KernelSignature DiagonalOpArgumentMapping(const ArgumentMappingContext& ctx) {
  paddle::small_vector<const char*> inputs {"Input"};
  paddle::small_vector<const char*> attrs;
  attrs.emplace_back("offset");
  attrs.emplace_back("axis1");
  attrs.emplace_back("axis2");
  paddle::small_vector<const char*> outputs {"Out"};
  KernelSignature sig("diagonal", std::move(inputs), std::move(attrs), std::move(outputs));
  return sig;
}

/*
******************************************************************
NOTE: The following codes are for 'get_compat_kernel_signature.py'
All possible KernelSignatures returned by DiagonalOpArgumentMapping:

return KernelSignature("diagonal", {"Input"}, {"offset", "axis1", "axis2"}, {"Out"});
******************************************************************
*/

KernelSignature DigammaOpArgumentMapping(const ArgumentMappingContext& ctx) {
  paddle::small_vector<const char*> inputs {"X"};
  paddle::small_vector<const char*> attrs;
  paddle::small_vector<const char*> outputs {"Out"};
  KernelSignature sig("digamma", std::move(inputs), std::move(attrs), std::move(outputs));
  return sig;
}

/*
******************************************************************
NOTE: The following codes are for 'get_compat_kernel_signature.py'
All possible KernelSignatures returned by DigammaOpArgumentMapping:

return KernelSignature("digamma", {"X"}, {}, {"Out"});
******************************************************************
*/

KernelSignature DistOpArgumentMapping(const ArgumentMappingContext& ctx) {
  paddle::small_vector<const char*> inputs {"X", "Y"};
  paddle::small_vector<const char*> attrs;
  attrs.emplace_back("p");
  paddle::small_vector<const char*> outputs {"Out"};
  KernelSignature sig("dist", std::move(inputs), std::move(attrs), std::move(outputs));
  return sig;
}

/*
******************************************************************
NOTE: The following codes are for 'get_compat_kernel_signature.py'
All possible KernelSignatures returned by DistOpArgumentMapping:

return KernelSignature("dist", {"X", "Y"}, {"p"}, {"Out"});
******************************************************************
*/

KernelSignature DotOpArgumentMapping(const ArgumentMappingContext& ctx) {
  paddle::small_vector<const char*> inputs {"X", "Y"};
  paddle::small_vector<const char*> attrs;
  paddle::small_vector<const char*> outputs {"Out"};
  KernelSignature sig("dot", std::move(inputs), std::move(attrs), std::move(outputs));
  return sig;
}

/*
******************************************************************
NOTE: The following codes are for 'get_compat_kernel_signature.py'
All possible KernelSignatures returned by DotOpArgumentMapping:

return KernelSignature("dot", {"X", "Y"}, {}, {"Out"});
******************************************************************
*/

KernelSignature ErfOpArgumentMapping(const ArgumentMappingContext& ctx) {
  paddle::small_vector<const char*> inputs {"X"};
  paddle::small_vector<const char*> attrs;
  paddle::small_vector<const char*> outputs {"Out"};
  KernelSignature sig("erf", std::move(inputs), std::move(attrs), std::move(outputs));
  return sig;
}

/*
******************************************************************
NOTE: The following codes are for 'get_compat_kernel_signature.py'
All possible KernelSignatures returned by ErfOpArgumentMapping:

return KernelSignature("erf", {"X"}, {}, {"Out"});
******************************************************************
*/

KernelSignature MvOpArgumentMapping(const ArgumentMappingContext& ctx) {
  paddle::small_vector<const char*> inputs {"X", "Vec"};
  paddle::small_vector<const char*> attrs;
  paddle::small_vector<const char*> outputs {"Out"};
  KernelSignature sig("mv", std::move(inputs), std::move(attrs), std::move(outputs));
  return sig;
}

/*
******************************************************************
NOTE: The following codes are for 'get_compat_kernel_signature.py'
All possible KernelSignatures returned by MvOpArgumentMapping:

return KernelSignature("mv", {"X", "Vec"}, {}, {"Out"});
******************************************************************
*/

KernelSignature PoissonOpArgumentMapping(const ArgumentMappingContext& ctx) {
  paddle::small_vector<const char*> inputs {"X"};
  paddle::small_vector<const char*> attrs;
  paddle::small_vector<const char*> outputs {"Out"};
  KernelSignature sig("poisson", std::move(inputs), std::move(attrs), std::move(outputs));
  return sig;
}

/*
******************************************************************
NOTE: The following codes are for 'get_compat_kernel_signature.py'
All possible KernelSignatures returned by PoissonOpArgumentMapping:

return KernelSignature("poisson", {"X"}, {}, {"Out"});
******************************************************************
*/

KernelSignature TraceOpArgumentMapping(const ArgumentMappingContext& ctx) {
  paddle::small_vector<const char*> inputs {"Input"};
  paddle::small_vector<const char*> attrs;
  attrs.emplace_back("offset");
  attrs.emplace_back("axis1");
  attrs.emplace_back("axis2");
  paddle::small_vector<const char*> outputs {"Out"};
  KernelSignature sig("trace", std::move(inputs), std::move(attrs), std::move(outputs));
  return sig;
}

/*
******************************************************************
NOTE: The following codes are for 'get_compat_kernel_signature.py'
All possible KernelSignatures returned by TraceOpArgumentMapping:

return KernelSignature("trace", {"Input"}, {"offset", "axis1", "axis2"}, {"Out"});
******************************************************************
*/

KernelSignature TruncOpArgumentMapping(const ArgumentMappingContext& ctx) {
  paddle::small_vector<const char*> inputs {"X"};
  paddle::small_vector<const char*> attrs;
  paddle::small_vector<const char*> outputs {"Out"};
  KernelSignature sig("trunc", std::move(inputs), std::move(attrs), std::move(outputs));
  return sig;
}

/*
******************************************************************
NOTE: The following codes are for 'get_compat_kernel_signature.py'
All possible KernelSignatures returned by TruncOpArgumentMapping:

return KernelSignature("trunc", {"X"}, {}, {"Out"});
******************************************************************
*/

KernelSignature Atan2GradOpArgumentMapping(const ArgumentMappingContext& ctx) {
  paddle::small_vector<const char*> inputs {"X1", "X2", "Out@GRAD"};
  paddle::small_vector<const char*> attrs;
  paddle::small_vector<const char*> outputs {"X1@GRAD", "X2@GRAD"};
  KernelSignature sig("atan2_grad", std::move(inputs), std::move(attrs), std::move(outputs));
  return sig;
}

/*
******************************************************************
NOTE: The following codes are for 'get_compat_kernel_signature.py'
All possible KernelSignatures returned by Atan2GradOpArgumentMapping:

return KernelSignature("atan2_grad", {"X1", "X2", "Out@GRAD"}, {}, {"X1@GRAD", "X2@GRAD"});
******************************************************************
*/

KernelSignature CholeskyGradOpArgumentMapping(const ArgumentMappingContext& ctx) {
  paddle::small_vector<const char*> inputs {"Out", "Out@GRAD"};
  paddle::small_vector<const char*> attrs;
  attrs.emplace_back("upper");
  paddle::small_vector<const char*> outputs {"X@GRAD"};
  KernelSignature sig("cholesky_grad", std::move(inputs), std::move(attrs), std::move(outputs));
  return sig;
}

/*
******************************************************************
NOTE: The following codes are for 'get_compat_kernel_signature.py'
All possible KernelSignatures returned by CholeskyGradOpArgumentMapping:

return KernelSignature("cholesky_grad", {"Out", "Out@GRAD"}, {"upper"}, {"X@GRAD"});
******************************************************************
*/

KernelSignature CholeskySolveGradOpArgumentMapping(const ArgumentMappingContext& ctx) {
  paddle::small_vector<const char*> inputs {"X", "Y", "Out", "Out@GRAD"};
  paddle::small_vector<const char*> attrs;
  attrs.emplace_back("upper");
  paddle::small_vector<const char*> outputs {"X@GRAD", "Y@GRAD"};
  KernelSignature sig("cholesky_solve_grad", std::move(inputs), std::move(attrs), std::move(outputs));
  return sig;
}

/*
******************************************************************
NOTE: The following codes are for 'get_compat_kernel_signature.py'
All possible KernelSignatures returned by CholeskySolveGradOpArgumentMapping:

return KernelSignature("cholesky_solve_grad", {"X", "Y", "Out", "Out@GRAD"}, {"upper"}, {"X@GRAD", "Y@GRAD"});
******************************************************************
*/

KernelSignature CrossGradOpArgumentMapping(const ArgumentMappingContext& ctx) {
  paddle::small_vector<const char*> inputs {"X", "Y", "Out@GRAD"};
  paddle::small_vector<const char*> attrs;
  attrs.emplace_back("dim");
  paddle::small_vector<const char*> outputs {"X@GRAD", "Y@GRAD"};
  KernelSignature sig("cross_grad", std::move(inputs), std::move(attrs), std::move(outputs));
  return sig;
}

/*
******************************************************************
NOTE: The following codes are for 'get_compat_kernel_signature.py'
All possible KernelSignatures returned by CrossGradOpArgumentMapping:

return KernelSignature("cross_grad", {"X", "Y", "Out@GRAD"}, {"dim"}, {"X@GRAD", "Y@GRAD"});
******************************************************************
*/

KernelSignature DiagGradOpArgumentMapping(const ArgumentMappingContext& ctx) {
  paddle::small_vector<const char*> inputs {"X", "Out@GRAD"};
  paddle::small_vector<const char*> attrs;
  attrs.emplace_back("offset");
  paddle::small_vector<const char*> outputs {"X@GRAD"};
  KernelSignature sig("diag_grad", std::move(inputs), std::move(attrs), std::move(outputs));
  return sig;
}

/*
******************************************************************
NOTE: The following codes are for 'get_compat_kernel_signature.py'
All possible KernelSignatures returned by DiagGradOpArgumentMapping:

return KernelSignature("diag_grad", {"X", "Out@GRAD"}, {"offset"}, {"X@GRAD"});
******************************************************************
*/

KernelSignature DiagonalGradOpArgumentMapping(const ArgumentMappingContext& ctx) {
  paddle::small_vector<const char*> inputs {"Input", "Out@GRAD"};
  paddle::small_vector<const char*> attrs;
  attrs.emplace_back("offset");
  attrs.emplace_back("axis1");
  attrs.emplace_back("axis2");
  paddle::small_vector<const char*> outputs {"Input@GRAD"};
  KernelSignature sig("diagonal_grad", std::move(inputs), std::move(attrs), std::move(outputs));
  return sig;
}

/*
******************************************************************
NOTE: The following codes are for 'get_compat_kernel_signature.py'
All possible KernelSignatures returned by DiagonalGradOpArgumentMapping:

return KernelSignature("diagonal_grad", {"Input", "Out@GRAD"}, {"offset", "axis1", "axis2"}, {"Input@GRAD"});
******************************************************************
*/

KernelSignature DigammaGradOpArgumentMapping(const ArgumentMappingContext& ctx) {
  paddle::small_vector<const char*> inputs {"X", "Out@GRAD"};
  paddle::small_vector<const char*> attrs;
  paddle::small_vector<const char*> outputs {"X@GRAD"};
  KernelSignature sig("digamma_grad", std::move(inputs), std::move(attrs), std::move(outputs));
  return sig;
}

/*
******************************************************************
NOTE: The following codes are for 'get_compat_kernel_signature.py'
All possible KernelSignatures returned by DigammaGradOpArgumentMapping:

return KernelSignature("digamma_grad", {"X", "Out@GRAD"}, {}, {"X@GRAD"});
******************************************************************
*/

KernelSignature DistGradOpArgumentMapping(const ArgumentMappingContext& ctx) {
  paddle::small_vector<const char*> inputs {"X", "Y", "Out", "Out@GRAD"};
  paddle::small_vector<const char*> attrs;
  attrs.emplace_back("p");
  paddle::small_vector<const char*> outputs {"X@GRAD", "Y@GRAD"};
  KernelSignature sig("dist_grad", std::move(inputs), std::move(attrs), std::move(outputs));
  return sig;
}

/*
******************************************************************
NOTE: The following codes are for 'get_compat_kernel_signature.py'
All possible KernelSignatures returned by DistGradOpArgumentMapping:

return KernelSignature("dist_grad", {"X", "Y", "Out", "Out@GRAD"}, {"p"}, {"X@GRAD", "Y@GRAD"});
******************************************************************
*/

KernelSignature DotGradOpArgumentMapping(const ArgumentMappingContext& ctx) {
  paddle::small_vector<const char*> inputs {"X", "Y", "Out@GRAD"};
  paddle::small_vector<const char*> attrs;
  paddle::small_vector<const char*> outputs {"X@GRAD", "Y@GRAD"};
  KernelSignature sig("dot_grad", std::move(inputs), std::move(attrs), std::move(outputs));
  return sig;
}

/*
******************************************************************
NOTE: The following codes are for 'get_compat_kernel_signature.py'
All possible KernelSignatures returned by DotGradOpArgumentMapping:

return KernelSignature("dot_grad", {"X", "Y", "Out@GRAD"}, {}, {"X@GRAD", "Y@GRAD"});
******************************************************************
*/

KernelSignature ErfGradOpArgumentMapping(const ArgumentMappingContext& ctx) {
  paddle::small_vector<const char*> inputs {"X", "Out@GRAD"};
  paddle::small_vector<const char*> attrs;
  paddle::small_vector<const char*> outputs {"X@GRAD"};
  KernelSignature sig("erf_grad", std::move(inputs), std::move(attrs), std::move(outputs));
  return sig;
}

/*
******************************************************************
NOTE: The following codes are for 'get_compat_kernel_signature.py'
All possible KernelSignatures returned by ErfGradOpArgumentMapping:

return KernelSignature("erf_grad", {"X", "Out@GRAD"}, {}, {"X@GRAD"});
******************************************************************
*/

KernelSignature MvGradOpArgumentMapping(const ArgumentMappingContext& ctx) {
  paddle::small_vector<const char*> inputs {"X", "Vec", "Out@GRAD"};
  paddle::small_vector<const char*> attrs;
  paddle::small_vector<const char*> outputs {"X@GRAD", "Vec@GRAD"};
  KernelSignature sig("mv_grad", std::move(inputs), std::move(attrs), std::move(outputs));
  return sig;
}

/*
******************************************************************
NOTE: The following codes are for 'get_compat_kernel_signature.py'
All possible KernelSignatures returned by MvGradOpArgumentMapping:

return KernelSignature("mv_grad", {"X", "Vec", "Out@GRAD"}, {}, {"X@GRAD", "Vec@GRAD"});
******************************************************************
*/

KernelSignature PoissonGradOpArgumentMapping(const ArgumentMappingContext& ctx) {
  paddle::small_vector<const char*> inputs {"Out@GRAD"};
  paddle::small_vector<const char*> attrs;
  paddle::small_vector<const char*> outputs {"X@GRAD"};
  KernelSignature sig("poisson_grad", std::move(inputs), std::move(attrs), std::move(outputs));
  return sig;
}

/*
******************************************************************
NOTE: The following codes are for 'get_compat_kernel_signature.py'
All possible KernelSignatures returned by PoissonGradOpArgumentMapping:

return KernelSignature("poisson_grad", {"Out@GRAD"}, {}, {"X@GRAD"});
******************************************************************
*/

KernelSignature TraceGradOpArgumentMapping(const ArgumentMappingContext& ctx) {
  paddle::small_vector<const char*> inputs {"Input", "Out@GRAD"};
  paddle::small_vector<const char*> attrs;
  attrs.emplace_back("offset");
  attrs.emplace_back("axis1");
  attrs.emplace_back("axis2");
  paddle::small_vector<const char*> outputs {"Input@GRAD"};
  KernelSignature sig("trace_grad", std::move(inputs), std::move(attrs), std::move(outputs));
  return sig;
}

/*
******************************************************************
NOTE: The following codes are for 'get_compat_kernel_signature.py'
All possible KernelSignatures returned by TraceGradOpArgumentMapping:

return KernelSignature("trace_grad", {"Input", "Out@GRAD"}, {"offset", "axis1", "axis2"}, {"Input@GRAD"});
******************************************************************
*/

KernelSignature TruncGradOpArgumentMapping(const ArgumentMappingContext& ctx) {
  paddle::small_vector<const char*> inputs {"Out@GRAD"};
  paddle::small_vector<const char*> attrs;
  paddle::small_vector<const char*> outputs {"X@GRAD"};
  KernelSignature sig("trunc_grad", std::move(inputs), std::move(attrs), std::move(outputs));
  return sig;
}

/*
******************************************************************
NOTE: The following codes are for 'get_compat_kernel_signature.py'
All possible KernelSignatures returned by TruncGradOpArgumentMapping:

return KernelSignature("trunc_grad", {"Out@GRAD"}, {}, {"X@GRAD"});
******************************************************************
*/

}  // namespace phi

PD_REGISTER_ARG_MAPPING_FN(atan2, phi::Atan2OpArgumentMapping);
PD_REGISTER_ARG_MAPPING_FN(bernoulli, phi::BernoulliOpArgumentMapping);
PD_REGISTER_ARG_MAPPING_FN(cholesky, phi::CholeskyOpArgumentMapping);
PD_REGISTER_ARG_MAPPING_FN(cholesky_solve, phi::CholeskySolveOpArgumentMapping);
PD_REGISTER_ARG_MAPPING_FN(cross, phi::CrossOpArgumentMapping);
PD_REGISTER_BASE_KERNEL_NAME(diag_v2, diag);
PD_REGISTER_ARG_MAPPING_FN(diag_v2, phi::DiagOpArgumentMapping);
PD_REGISTER_ARG_MAPPING_FN(diagonal, phi::DiagonalOpArgumentMapping);
PD_REGISTER_ARG_MAPPING_FN(digamma, phi::DigammaOpArgumentMapping);
PD_REGISTER_ARG_MAPPING_FN(dist, phi::DistOpArgumentMapping);
PD_REGISTER_ARG_MAPPING_FN(dot, phi::DotOpArgumentMapping);
PD_REGISTER_ARG_MAPPING_FN(erf, phi::ErfOpArgumentMapping);
PD_REGISTER_ARG_MAPPING_FN(mv, phi::MvOpArgumentMapping);
PD_REGISTER_ARG_MAPPING_FN(poisson, phi::PoissonOpArgumentMapping);
PD_REGISTER_ARG_MAPPING_FN(trace, phi::TraceOpArgumentMapping);
PD_REGISTER_ARG_MAPPING_FN(trunc, phi::TruncOpArgumentMapping);
PD_REGISTER_ARG_MAPPING_FN(atan2_grad, phi::Atan2GradOpArgumentMapping);
PD_REGISTER_ARG_MAPPING_FN(cholesky_grad, phi::CholeskyGradOpArgumentMapping);
PD_REGISTER_ARG_MAPPING_FN(cholesky_solve_grad, phi::CholeskySolveGradOpArgumentMapping);
PD_REGISTER_ARG_MAPPING_FN(cross_grad, phi::CrossGradOpArgumentMapping);
PD_REGISTER_BASE_KERNEL_NAME(diag_v2_grad, diag_grad);
PD_REGISTER_ARG_MAPPING_FN(diag_v2_grad, phi::DiagGradOpArgumentMapping);
PD_REGISTER_ARG_MAPPING_FN(diagonal_grad, phi::DiagonalGradOpArgumentMapping);
PD_REGISTER_ARG_MAPPING_FN(digamma_grad, phi::DigammaGradOpArgumentMapping);
PD_REGISTER_ARG_MAPPING_FN(dist_grad, phi::DistGradOpArgumentMapping);
PD_REGISTER_ARG_MAPPING_FN(dot_grad, phi::DotGradOpArgumentMapping);
PD_REGISTER_ARG_MAPPING_FN(erf_grad, phi::ErfGradOpArgumentMapping);
PD_REGISTER_ARG_MAPPING_FN(mv_grad, phi::MvGradOpArgumentMapping);
PD_REGISTER_ARG_MAPPING_FN(poisson_grad, phi::PoissonGradOpArgumentMapping);
PD_REGISTER_ARG_MAPPING_FN(trace_grad, phi::TraceGradOpArgumentMapping);
PD_REGISTER_ARG_MAPPING_FN(trunc_grad, phi::TruncGradOpArgumentMapping);
