// 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 ErfinvOpArgumentMapping(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("erfinv", 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 ErfinvOpArgumentMapping:

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

KernelSignature FftC2cOpArgumentMapping(const ArgumentMappingContext& ctx) {
  paddle::small_vector<const char*> inputs {"X"};
  paddle::small_vector<const char*> attrs;
  attrs.emplace_back("axes");
  attrs.emplace_back("normalization");
  attrs.emplace_back("forward");
  paddle::small_vector<const char*> outputs {"Out"};
  KernelSignature sig("fft_c2c", 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 FftC2cOpArgumentMapping:

return KernelSignature("fft_c2c", {"X"}, {"axes", "normalization", "forward"}, {"Out"});
******************************************************************
*/

KernelSignature FftC2rOpArgumentMapping(const ArgumentMappingContext& ctx) {
  paddle::small_vector<const char*> inputs {"X"};
  paddle::small_vector<const char*> attrs;
  attrs.emplace_back("axes");
  attrs.emplace_back("normalization");
  attrs.emplace_back("forward");
  attrs.emplace_back("last_dim_size");
  paddle::small_vector<const char*> outputs {"Out"};
  KernelSignature sig("fft_c2r", 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 FftC2rOpArgumentMapping:

return KernelSignature("fft_c2r", {"X"}, {"axes", "normalization", "forward", "last_dim_size"}, {"Out"});
******************************************************************
*/

KernelSignature FftR2cOpArgumentMapping(const ArgumentMappingContext& ctx) {
  paddle::small_vector<const char*> inputs {"X"};
  paddle::small_vector<const char*> attrs;
  attrs.emplace_back("axes");
  attrs.emplace_back("normalization");
  attrs.emplace_back("forward");
  attrs.emplace_back("onesided");
  paddle::small_vector<const char*> outputs {"Out"};
  KernelSignature sig("fft_r2c", 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 FftR2cOpArgumentMapping:

return KernelSignature("fft_r2c", {"X"}, {"axes", "normalization", "forward", "onesided"}, {"Out"});
******************************************************************
*/

KernelSignature GraphSendUvOpArgumentMapping(const ArgumentMappingContext& ctx) {
  paddle::small_vector<const char*> inputs {"x", "y", "src_index", "dst_index"};
  paddle::small_vector<const char*> attrs;
  attrs.emplace_back("message_op");
  paddle::small_vector<const char*> outputs {"out"};
  KernelSignature sig("graph_send_uv", 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 GraphSendUvOpArgumentMapping:

return KernelSignature("graph_send_uv", {"x", "y", "src_index", "dst_index"}, {"message_op"}, {"out"});
******************************************************************
*/

KernelSignature LgammaOpArgumentMapping(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("lgamma", 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 LgammaOpArgumentMapping:

return KernelSignature("lgamma", {"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 SolveOpArgumentMapping(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("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 SolveOpArgumentMapping:

return KernelSignature("solve", {"X", "Y"}, {}, {"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 FlipOpArgumentMapping(const ArgumentMappingContext& ctx) {
  paddle::small_vector<const char*> inputs {"X"};
  paddle::small_vector<const char*> attrs;
  attrs.emplace_back("axis");
  paddle::small_vector<const char*> outputs {"Out"};
  KernelSignature sig("flip", 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 FlipOpArgumentMapping:

return KernelSignature("flip", {"X"}, {"axis"}, {"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 ErfinvGradOpArgumentMapping(const ArgumentMappingContext& ctx) {
  paddle::small_vector<const char*> inputs {"Out", "Out@GRAD"};
  paddle::small_vector<const char*> attrs;
  paddle::small_vector<const char*> outputs {"X@GRAD"};
  KernelSignature sig("erfinv_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 ErfinvGradOpArgumentMapping:

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

KernelSignature FftC2cGradOpArgumentMapping(const ArgumentMappingContext& ctx) {
  paddle::small_vector<const char*> inputs {"Out@GRAD"};
  paddle::small_vector<const char*> attrs;
  attrs.emplace_back("axes");
  attrs.emplace_back("normalization");
  attrs.emplace_back("forward");
  paddle::small_vector<const char*> outputs {"X@GRAD"};
  KernelSignature sig("fft_c2c_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 FftC2cGradOpArgumentMapping:

return KernelSignature("fft_c2c_grad", {"Out@GRAD"}, {"axes", "normalization", "forward"}, {"X@GRAD"});
******************************************************************
*/

KernelSignature FftC2rGradOpArgumentMapping(const ArgumentMappingContext& ctx) {
  paddle::small_vector<const char*> inputs {"Out@GRAD"};
  paddle::small_vector<const char*> attrs;
  attrs.emplace_back("axes");
  attrs.emplace_back("normalization");
  attrs.emplace_back("forward");
  attrs.emplace_back("last_dim_size");
  paddle::small_vector<const char*> outputs {"X@GRAD"};
  KernelSignature sig("fft_c2r_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 FftC2rGradOpArgumentMapping:

return KernelSignature("fft_c2r_grad", {"Out@GRAD"}, {"axes", "normalization", "forward", "last_dim_size"}, {"X@GRAD"});
******************************************************************
*/

KernelSignature FftR2cGradOpArgumentMapping(const ArgumentMappingContext& ctx) {
  paddle::small_vector<const char*> inputs {"X", "Out@GRAD"};
  paddle::small_vector<const char*> attrs;
  attrs.emplace_back("axes");
  attrs.emplace_back("normalization");
  attrs.emplace_back("forward");
  attrs.emplace_back("onesided");
  paddle::small_vector<const char*> outputs {"X@GRAD"};
  KernelSignature sig("fft_r2c_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 FftR2cGradOpArgumentMapping:

return KernelSignature("fft_r2c_grad", {"X", "Out@GRAD"}, {"axes", "normalization", "forward", "onesided"}, {"X@GRAD"});
******************************************************************
*/

KernelSignature GraphSendUvGradOpArgumentMapping(const ArgumentMappingContext& ctx) {
  paddle::small_vector<const char*> inputs {"x", "y", "src_index", "dst_index", "out@GRAD"};
  paddle::small_vector<const char*> attrs;
  attrs.emplace_back("message_op");
  paddle::small_vector<const char*> outputs {"x@GRAD", "y@GRAD"};
  KernelSignature sig("graph_send_uv_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 GraphSendUvGradOpArgumentMapping:

return KernelSignature("graph_send_uv_grad", {"x", "y", "src_index", "dst_index", "out@GRAD"}, {"message_op"}, {"x@GRAD", "y@GRAD"});
******************************************************************
*/

KernelSignature LgammaGradOpArgumentMapping(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("lgamma_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 LgammaGradOpArgumentMapping:

return KernelSignature("lgamma_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 SolveGradOpArgumentMapping(const ArgumentMappingContext& ctx) {
  paddle::small_vector<const char*> inputs {"X", "Y", "Out", "Out@GRAD"};
  paddle::small_vector<const char*> attrs;
  paddle::small_vector<const char*> outputs {"X@GRAD", "Y@GRAD"};
  KernelSignature sig("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 SolveGradOpArgumentMapping:

return KernelSignature("solve_grad", {"X", "Y", "Out", "Out@GRAD"}, {}, {"X@GRAD", "Y@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(erfinv, phi::ErfinvOpArgumentMapping);
PD_REGISTER_ARG_MAPPING_FN(fft_c2c, phi::FftC2cOpArgumentMapping);
PD_REGISTER_ARG_MAPPING_FN(fft_c2r, phi::FftC2rOpArgumentMapping);
PD_REGISTER_ARG_MAPPING_FN(fft_r2c, phi::FftR2cOpArgumentMapping);
PD_REGISTER_ARG_MAPPING_FN(graph_send_uv, phi::GraphSendUvOpArgumentMapping);
PD_REGISTER_ARG_MAPPING_FN(lgamma, phi::LgammaOpArgumentMapping);
PD_REGISTER_ARG_MAPPING_FN(mv, phi::MvOpArgumentMapping);
PD_REGISTER_ARG_MAPPING_FN(poisson, phi::PoissonOpArgumentMapping);
PD_REGISTER_ARG_MAPPING_FN(solve, phi::SolveOpArgumentMapping);
PD_REGISTER_ARG_MAPPING_FN(trace, phi::TraceOpArgumentMapping);
PD_REGISTER_ARG_MAPPING_FN(trunc, phi::TruncOpArgumentMapping);
PD_REGISTER_ARG_MAPPING_FN(flip, phi::FlipOpArgumentMapping);
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(erfinv_grad, phi::ErfinvGradOpArgumentMapping);
PD_REGISTER_ARG_MAPPING_FN(fft_c2c_grad, phi::FftC2cGradOpArgumentMapping);
PD_REGISTER_ARG_MAPPING_FN(fft_c2r_grad, phi::FftC2rGradOpArgumentMapping);
PD_REGISTER_ARG_MAPPING_FN(fft_r2c_grad, phi::FftR2cGradOpArgumentMapping);
PD_REGISTER_ARG_MAPPING_FN(graph_send_uv_grad, phi::GraphSendUvGradOpArgumentMapping);
PD_REGISTER_ARG_MAPPING_FN(lgamma_grad, phi::LgammaGradOpArgumentMapping);
PD_REGISTER_ARG_MAPPING_FN(mv_grad, phi::MvGradOpArgumentMapping);
PD_REGISTER_ARG_MAPPING_FN(poisson_grad, phi::PoissonGradOpArgumentMapping);
PD_REGISTER_ARG_MAPPING_FN(solve_grad, phi::SolveGradOpArgumentMapping);
PD_REGISTER_ARG_MAPPING_FN(trace_grad, phi::TraceGradOpArgumentMapping);
PD_REGISTER_ARG_MAPPING_FN(trunc_grad, phi::TruncGradOpArgumentMapping);
