	.file	"330829.c"
	.intel_syntax noprefix
	.text
	.globl	clang___clang_cuda_cmath_buf
	.data
	.align 32
	.type	clang___clang_cuda_cmath_buf, @object
	.size	clang___clang_cuda_cmath_buf, 17609
clang___clang_cuda_cmath_buf:
	.ascii	"/*===---- __clang_cuda_cmath.h - Device-side CUDA cmath supp"
	.ascii	"ort ------------===\n *\n * Permission is hereby granted, fr"
	.ascii	"ee of charge, to any person obtaining a copy\n * of this sof"
	.ascii	"tware and associated documentation files (the \"Software\"),"
	.ascii	" to deal\n * in the Software without restriction, including "
	.ascii	"without limitation the rights\n * to use, copy, modify, merg"
	.ascii	"e, publish, distribute, sublicense, and/or sell\n * copies o"
	.ascii	"f the Software, and to permit persons to whom the Software i"
	.ascii	"s\n * furnished to do so, subject to the following condition"
	.ascii	"s:\n *\n * The above copyright notice and this permission no"
	.ascii	"tice shall be included in\n * all copies or substantial port"
	.ascii	"ions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS "
	.ascii	"IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, "
	.ascii	"INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILI"
	.ascii	"TY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT"
	.ascii	". IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE "
	.ascii	"LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHE"
	.ascii	"R IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,"
	.ascii	"\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR"
	.ascii	" OTHER DEALINGS IN\n * THE SOFTWARE.\n *\n *===-------------"
	.ascii	"----------------------------------------------------------=="
	.ascii	"=\n */\n#ifndef __CLANG_CUDA_CMATH_H__\n#define __CLANG_CUDA"
	.ascii	"_CMATH_H__\n#ifndef __CUDA__\n#error \"This file is for CUDA"
	.ascii	" compilation only.\"\n#endif\n\n#include <limits>\n\n// CUDA"
	.ascii	" lets us use various std math functions on the device side. "
	.ascii	" This file\n// works in concert with __clang_cuda_math_forwa"
	.ascii	"rd_declares.h to make this work.\n//\n// Specifically, the f"
	.ascii	"orward-declares header declares __device__ overloads for\n//"
	.ascii	" these functions in the global namespace, then pulls them in"
	.ascii	"to namespace std\n// with 'using' statements.  Then this fil"
	.ascii	"e implements those functions, after\n// their implementation"
	.ascii	"s have been pulled in.\n//\n// It's important that we declar"
	.ascii	"e the functions in the global namespace and pull\n// them in"
	.ascii	"to namespace std with using statements, as opposed to simply"
	.ascii	" decl"
	.ascii	"aring\n// these functions in namespace std, because our devi"
	.ascii	"ce functions need to\n// overload the standard library funct"
	.ascii	"ions, which may be declared in the global\n// namespace or i"
	.ascii	"n std, depending on the degree of conformance of the stdlib\n"
	.ascii	"// implementation.  Declaring in the global namespace and pu"
	.ascii	"lling into namespace\n// std covers all of the known knowns."
	.ascii	"\n\n#define __DEVICE__ static __device__ __inline__ __attrib"
	.ascii	"ute__((always_inline))\n\n__DEVICE__ long long abs(long long"
	.ascii	" __n) { return ::llabs(__n); }\n__DEVICE__ long abs(long __n"
	.ascii	") { return ::labs(__n); }\n__DEVICE__ float abs(float __x) {"
	.ascii	" return ::fabsf(__x); }\n__DEVICE__ double abs(double __x) {"
	.ascii	" return ::fabs(__x); }\n__DEVICE__ float acos(float __x) { r"
	.ascii	"eturn ::acosf(__x); }\n__DEVICE__ float asin(float __x) { re"
	.ascii	"turn ::asinf(__x); }\n__DEVICE__ float atan(float __x) { ret"
	.ascii	"urn ::atanf(__x); }\n__DEVICE__ float atan2(float __x, float"
	.ascii	" __y) { return ::atan2f(__x, __y); }\n__DEVICE__ float ceil("
	.ascii	"float __x) { return ::ceilf(__x); }\n__DEVICE__ float cos(fl"
	.ascii	"oat __x) { return ::cosf(__x); }\n__DEVICE__ float cosh(floa"
	.ascii	"t __x) { return ::coshf(__x); }\n__DEVICE__ float exp(float "
	.ascii	"__x) { return ::expf(__x); }\n__DEVICE__ float fabs(float __"
	.ascii	"x) { return ::fabsf(__x); }\n__DEVICE__ float floor(float __"
	.ascii	"x) { return ::floorf(__x); }\n__DEVICE__ float fmod(float __"
	.ascii	"x, float __y) { return ::fmodf(__x, __y); }\n__DEVICE__ int "
	.ascii	"fpclassify(float __x) {\n  return __builtin_fpclassify(FP_NA"
	.ascii	"N, FP_INFINITE, FP_NORMAL, FP_SUBNORMAL,\n                  "
	.ascii	"            FP_ZERO, __x);\n}\n__DEVICE__ int fpclassify(dou"
	.ascii	"ble __x) {\n  return __builtin_fpclassify(FP_NAN, FP_INFINIT"
	.ascii	"E, FP_NORMAL, FP_SUBNORMAL,\n                              F"
	.ascii	"P_ZERO, __x);\n}\n__DEVICE__ float frexp(float __arg, int *_"
	.ascii	"_exp) {\n  return ::frexpf(__arg, __exp);\n}\n\n// For inscr"
	.ascii	"utable reasons, the CUDA headers define these functions for "
	.ascii	"us on\n// Windows.\n#ifndef _MSC_VER\n__DEVICE__ bool isinf("
	.ascii	"float __x) { return ::__isinff(__x); }\n__DEVICE__ bool isin"
	.ascii	"f(double __x) { return ::__isinf(__x); }\n__DEVICE__ bool is"
	.ascii	"finite(float __x) { return ::__finitef(__x); }\n// For inscr"
	.ascii	"utable reasons, __finite(), the double-precision version of\n"
	.ascii	"// __finitef, does not exist when compiling for MacOS.  __is"
	.ascii	"finited is available\n// everywhere and is just as good.\n__"
	.ascii	"DEVICE__ bool isfinite(double __x) { return ::__isfinited(__"
	.ascii	"x); }\n__DEVICE__ bool isnan(float __x) { return ::__isnanf("
	.ascii	"__x); }\n__DEVICE__ bool isnan(double __x) { return ::__isna"
	.ascii	"n(__x); }\n#endif\n\n__DEVICE__ bool isgreater(float __x, fl"
	.ascii	"oat __y) {\n  return __builtin_isgreater(__x, __y);\n}\n__DE"
	.ascii	"VICE__ bool isgreater(double __x, double __y) {\n  return __"
	.ascii	"builtin_isgreater(__x, __y);\n}\n__DEVICE__ bool isgreatereq"
	.ascii	"ual(float __x, float __y) {\n  return __builtin_isgreaterequ"
	.ascii	"al(__x, __y);\n}\n__DEVICE__ bool isgreaterequal(double __x,"
	.ascii	" double __y) {\n  return __builtin_isgreaterequal(__x, __y);"
	.ascii	"\n}\n__DEVICE__ bool isless(float __x, float __y) {\n  retur"
	.ascii	"n __builtin_isless(__x, __y);\n}\n__DEVICE__ bool isless(dou"
	.ascii	"ble __x, double __y) {\n  return __builtin_isless(__x, __y);"
	.ascii	"\n}\n__DEVICE__ bool islessequal(float __x, float __y) {\n  "
	.ascii	"return __builtin_islessequal(__x, __y);\n}\n__DEVICE__ bool "
	.ascii	"islessequal(double __x, double __y) {\n  return __builtin_is"
	.ascii	"lessequal(__x, __y);\n}\n__DEVICE__ bool islessgreater(float"
	.ascii	" __x, float __y) {\n  return __builtin_islessgreater(__x, __"
	.ascii	"y);\n}\n__DEVICE__ bool islessgreater(double __x, double __y"
	.ascii	") {\n  return __builtin_islessgreater(__x, __y);\n}\n__DEVIC"
	.ascii	"E__ bool isnormal(float __x) { return __builtin_isnormal(__x"
	.ascii	"); }\n__DEVICE__ bool isnormal(double __x) { return __builti"
	.ascii	"n_isnormal(__x); }\n__DEVICE__ bool isunordered(float __x, f"
	.ascii	"loat __y) {\n  return __builtin_isunordered(__x, __y);\n}\n_"
	.ascii	"_DEVICE__ bool isunordered(double __x, double __y) {\n  retu"
	.ascii	"rn __builtin_isunordered(__x, __y);\n}\n__DEVICE__ float lde"
	.ascii	"xp(float __arg, int __exp) {\n  return ::ldexpf(__arg, __exp"
	.ascii	");\n}\n__DEVICE__ float log(float __x) { return ::logf(__x);"
	.ascii	" }\n__DEVICE__ float log10(float __x) { return ::log10f(__x)"
	.ascii	"; }\n__DEVICE__ float modf(float __x, float *__iptr) { retur"
	.ascii	"n ::modff(_"
	.ascii	"_x, __iptr); }\n__DEVICE__ float nexttoward(float __from, do"
	.ascii	"uble __to) {\n  return __builtin_nexttowardf(__from, __to);\n"
	.ascii	"}\n__DEVICE__ double nexttoward(double __from, double __to) "
	.ascii	"{\n  return __builtin_nexttoward(__from, __to);\n}\n__DEVICE"
	.ascii	"__ float nexttowardf(float __from, double __to) {\n  return "
	.ascii	"__builtin_nexttowardf(__from, __to);\n}\n__DEVICE__ float po"
	.ascii	"w(float __base, float __exp) {\n  return ::powf(__base, __ex"
	.ascii	"p);\n}\n__DEVICE__ float pow(float __base, int __iexp) {\n  "
	.ascii	"return ::powif(__base, __iexp);\n}\n__DEVICE__ double pow(do"
	.ascii	"uble __base, int __iexp) {\n  return ::powi(__base, __iexp);"
	.ascii	"\n}\n__DEVICE__ bool signbit(float __x) { return ::__signbit"
	.ascii	"f(__x); }\n__DEVICE__ bool signbit(double __x) { return ::__"
	.ascii	"signbitd(__x); }\n__DEVICE__ float sin(float __x) { return :"
	.ascii	":sinf(__x); }\n__DEVICE__ float sinh(float __x) { return ::s"
	.ascii	"inhf(__x); }\n__DEVICE__ float sqrt(float __x) { return ::sq"
	.ascii	"rtf(__x); }\n__DEVICE__ float tan(float __x) { return ::tanf"
	.ascii	"(__x); }\n__DEVICE__ float tanh(float __x) { return ::tanhf("
	.ascii	"__x); }\n\n// Now we've defined everything we promised we'd "
	.ascii	"define in\n// __clang_cuda_math_forward_declares.h.  We need"
	.ascii	" to do two additional things to\n// fix up our math function"
	.ascii	"s.\n//\n// 1) Define __device__ overloads for e.g. sin(int)."
	.ascii	"  The CUDA headers define\n//    only sin(float) and sin(dou"
	.ascii	"ble), which means that e.g. sin(0) is\n//    ambiguous.\n//\n"
	.ascii	"// 2) Pull the __device__ overloads of \"foobarf\" math func"
	.ascii	"tions into namespace\n//    std.  These are defined in the C"
	.ascii	"UDA headers in the global namespace,\n//    independent of e"
	.ascii	"verything else we've done here.\n\n// We can't use std::enab"
	.ascii	"le_if, because we want to be pre-C++11 compatible.  But\n// "
	.ascii	"we go ahead and unconditionally define functions that are on"
	.ascii	"ly available when\n// compiling for C++11 to match the behav"
	.ascii	"ior of the CUDA headers.\ntemplate<bool __B, class __T = voi"
	.ascii	"d>\nstruct __clang_cuda_enable_if {};\n\ntemplate <class __T"
	.ascii	"> struct __clang_cuda_enable_if<true, __T> {\n  typedef __T "
	.ascii	"type;\n};\n\n// Defines an overload of __fn that accepts one"
	.ascii	" integral"
	.ascii	" argument, calls\n// __fn((double)x), and returns __retty.\n"
	.ascii	"#define __CUDA_CLANG_FN_INTEGER_OVERLOAD_1(__retty, __fn)   "
	.ascii	"                   \\\n  template <typename __T>            "
	.ascii	"                                          \\\n  __DEVICE__  "
	.ascii	"                                                            "
	.ascii	"     \\\n      typename __clang_cuda_enable_if<std::numeric_"
	.ascii	"limits<__T>::is_integer,    \\\n                            "
	.ascii	"          __retty>::type                           \\\n     "
	.ascii	" __fn(__T __x) {                                            "
	.ascii	"              \\\n    return ::__fn((double)__x);           "
	.ascii	"                                     \\\n  }\n\n// Defines a"
	.ascii	"n overload of __fn that accepts one two arithmetic arguments"
	.ascii	", calls\n// __fn((double)x, (double)y), and returns a double"
	.ascii	".\n//\n// Note this is different from OVERLOAD_1, which gene"
	.ascii	"rates an overload that\n// accepts only *integral* arguments"
	.ascii	".\n#define __CUDA_CLANG_FN_INTEGER_OVERLOAD_2(__retty, __fn)"
	.ascii	"                      \\\n  template <typename __T1, typenam"
	.ascii	"e __T2>                                      \\\n  __DEVICE_"
	.ascii	"_ typename __clang_cuda_enable_if<                          "
	.ascii	"        \\\n      std::numeric_limits<__T1>::is_specialized "
	.ascii	"&&                             \\\n          std::numeric_li"
	.ascii	"mits<__T2>::is_specialized,                           \\\n  "
	.ascii	"    __retty>::type                                          "
	.ascii	"                 \\\n  __fn(__T1 __x, __T2 __y) {           "
	.ascii	"                                        \\\n    return __fn("
	.ascii	"(double)__x, (double)__y);                                  "
	.ascii	"   \\\n  }\n\n__CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, aco"
	.ascii	"s)\n__CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, acosh)\n__CUD"
	.ascii	"A_CLANG_FN_INTEGER_OVERLOAD_1(double, asin)\n__CUDA_CLANG_FN"
	.ascii	"_INTEGER_OVERLOAD_1(double, asinh)\n__CUDA_CLANG_FN_INTEGER_"
	.ascii	"OVERLOAD_1(double, atan)\n__CUDA_CLANG_FN_INTEGER_OVERLOAD_2"
	.ascii	"(double, atan2);\n__CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double,"
	.ascii	" atanh)\n__CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, cbrt)\n_"
	.ascii	"_CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, ceil)\n__CUDA_CLAN"
	.ascii	"G_FN_INTEG"
	.ascii	"ER_OVERLOAD_2(double, copysign);\n__CUDA_CLANG_FN_INTEGER_OV"
	.ascii	"ERLOAD_1(double, cos)\n__CUDA_CLANG_FN_INTEGER_OVERLOAD_1(do"
	.ascii	"uble, cosh)\n__CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, erf)"
	.ascii	"\n__CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, erfc)\n__CUDA_C"
	.ascii	"LANG_FN_INTEGER_OVERLOAD_1(double, exp)\n__CUDA_CLANG_FN_INT"
	.ascii	"EGER_OVERLOAD_1(double, exp2)\n__CUDA_CLANG_FN_INTEGER_OVERL"
	.ascii	"OAD_1(double, expm1)\n__CUDA_CLANG_FN_INTEGER_OVERLOAD_1(dou"
	.ascii	"ble, fabs)\n__CUDA_CLANG_FN_INTEGER_OVERLOAD_2(double, fdim)"
	.ascii	";\n__CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, floor)\n__CUDA"
	.ascii	"_CLANG_FN_INTEGER_OVERLOAD_2(double, fmax);\n__CUDA_CLANG_FN"
	.ascii	"_INTEGER_OVERLOAD_2(double, fmin);\n__CUDA_CLANG_FN_INTEGER_"
	.ascii	"OVERLOAD_2(double, fmod);\n__CUDA_CLANG_FN_INTEGER_OVERLOAD_"
	.ascii	"1(int, fpclassify)\n__CUDA_CLANG_FN_INTEGER_OVERLOAD_2(doubl"
	.ascii	"e, hypot);\n__CUDA_CLANG_FN_INTEGER_OVERLOAD_1(int, ilogb)\n"
	.ascii	"__CUDA_CLANG_FN_INTEGER_OVERLOAD_1(bool, isfinite)\n__CUDA_C"
	.ascii	"LANG_FN_INTEGER_OVERLOAD_2(bool, isgreater);\n__CUDA_CLANG_F"
	.ascii	"N_INTEGER_OVERLOAD_2(bool, isgreaterequal);\n__CUDA_CLANG_FN"
	.ascii	"_INTEGER_OVERLOAD_1(bool, isinf);\n__CUDA_CLANG_FN_INTEGER_O"
	.ascii	"VERLOAD_2(bool, isless);\n__CUDA_CLANG_FN_INTEGER_OVERLOAD_2"
	.ascii	"(bool, islessequal);\n__CUDA_CLANG_FN_INTEGER_OVERLOAD_2(boo"
	.ascii	"l, islessgreater);\n__CUDA_CLANG_FN_INTEGER_OVERLOAD_1(bool,"
	.ascii	" isnan);\n__CUDA_CLANG_FN_INTEGER_OVERLOAD_1(bool, isnormal)"
	.ascii	"\n__CUDA_CLANG_FN_INTEGER_OVERLOAD_2(bool, isunordered);\n__"
	.ascii	"CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, lgamma)\n__CUDA_CLA"
	.ascii	"NG_FN_INTEGER_OVERLOAD_1(double, log)\n__CUDA_CLANG_FN_INTEG"
	.ascii	"ER_OVERLOAD_1(double, log10)\n__CUDA_CLANG_FN_INTEGER_OVERLO"
	.ascii	"AD_1(double, log1p)\n__CUDA_CLANG_FN_INTEGER_OVERLOAD_1(doub"
	.ascii	"le, log2)\n__CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, logb)\n"
	.ascii	"__CUDA_CLANG_FN_INTEGER_OVERLOAD_1(long long, llrint)\n__CUD"
	.ascii	"A_CLANG_FN_INTEGER_OVERLOAD_1(long long, llround)\n__CUDA_CL"
	.ascii	"ANG_FN_INTEGER_OVERLOAD_1(long, lrint)\n__CUDA_CLANG_FN_INTE"
	.ascii	"GER_OVERLOAD_1(long, lround)\n__CUDA_CLANG_FN_INTEGER_OVERLO"
	.ascii	"AD_1(double, nearbyint);\n__CUDA_CLANG_FN_INTEGER_OVERLOAD_2"
	.ascii	"(double, nextafter);\n__CUDA_CLANG_FN_INTEGER_OVERLOAD_2(d"
	.ascii	"ouble, pow);\n__CUDA_CLANG_FN_INTEGER_OVERLOAD_2(double, rem"
	.ascii	"ainder);\n__CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, rint);\n"
	.ascii	"__CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, round);\n__CUDA_C"
	.ascii	"LANG_FN_INTEGER_OVERLOAD_1(bool, signbit)\n__CUDA_CLANG_FN_I"
	.ascii	"NTEGER_OVERLOAD_1(double, sin)\n__CUDA_CLANG_FN_INTEGER_OVER"
	.ascii	"LOAD_1(double, sinh)\n__CUDA_CLANG_FN_INTEGER_OVERLOAD_1(dou"
	.ascii	"ble, sqrt)\n__CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, tan)\n"
	.ascii	"__CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, tanh)\n__CUDA_CLA"
	.ascii	"NG_FN_INTEGER_OVERLOAD_1(double, tgamma)\n__CUDA_CLANG_FN_IN"
	.ascii	"TEGER_OVERLOAD_1(double, trunc);\n\n#undef __CUDA_CLANG_FN_I"
	.ascii	"NTEGER_OVERLOAD_1\n#undef __CUDA_CLANG_FN_INTEGER_OVERLOAD_2"
	.ascii	"\n\n// Overloads for functions that don't match the patterns"
	.ascii	" expected by\n// __CUDA_CLANG_FN_INTEGER_OVERLOAD_{1,2}.\nte"
	.ascii	"mplate <typename __T1, typename __T2, typename __T3>\n__DEVI"
	.ascii	"CE__ typename __clang_cuda_enable_if<\n    std::numeric_limi"
	.ascii	"ts<__T1>::is_specialized &&\n        std::numeric_limits<__T"
	.ascii	"2>::is_specialized &&\n        std::numeric_limits<__T3>::is"
	.ascii	"_specialized,\n    double>::type\nfma(__T1 __x, __T2 __y, __"
	.ascii	"T3 __z) {\n  return std::fma((double)__x, (double)__y, (doub"
	.ascii	"le)__z);\n}\n\ntemplate <typename __T>\n__DEVICE__ typename "
	.ascii	"__clang_cuda_enable_if<std::numeric_limits<__T>::is_integer,"
	.ascii	"\n                                           double>::type\n"
	.ascii	"frexp(__T __x, int *__exp) {\n  return std::frexp((double)__"
	.ascii	"x, __exp);\n}\n\ntemplate <typename __T>\n__DEVICE__ typenam"
	.ascii	"e __clang_cuda_enable_if<std::numeric_limits<__T>::is_intege"
	.ascii	"r,\n                                           double>::type"
	.ascii	"\nldexp(__T __x, int __exp) {\n  return std::ldexp((double)_"
	.ascii	"_x, __exp);\n}\n\ntemplate <typename __T>\n__DEVICE__ typena"
	.ascii	"me __clang_cuda_enable_if<std::numeric_limits<__T>::is_integ"
	.ascii	"er,\n                                           double>::typ"
	.ascii	"e\nnexttoward(__T __from, double __to) {\n  return std::next"
	.ascii	"toward((double)__from, __to);\n}\n\ntemplate <typename __T1,"
	.ascii	" typename __T2>\n__DEVICE__ typename __clang_cuda_enable_if<"
	.ascii	"\n    std::numeric_limits<__T1>::is_specialized &&\n        "
	.ascii	"std::numer"
	.ascii	"ic_limits<__T2>::is_specialized,\n    double>::type\nremquo("
	.ascii	"__T1 __x, __T2 __y, int *__quo) {\n  return std::remquo((dou"
	.ascii	"ble)__x, (double)__y, __quo);\n}\n\ntemplate <typename __T>\n"
	.ascii	"__DEVICE__ typename __clang_cuda_enable_if<std::numeric_limi"
	.ascii	"ts<__T>::is_integer,\n                                      "
	.ascii	"     double>::type\nscalbln(__T __x, long __exp) {\n  return"
	.ascii	" std::scalbln((double)__x, __exp);\n}\n\ntemplate <typename "
	.ascii	"__T>\n__DEVICE__ typename __clang_cuda_enable_if<std::numeri"
	.ascii	"c_limits<__T>::is_integer,\n                                "
	.ascii	"           double>::type\nscalbn(__T __x, int __exp) {\n  re"
	.ascii	"turn std::scalbn((double)__x, __exp);\n}\n\n// We need to de"
	.ascii	"fine these overloads in exactly the namespace our standard\n"
	.ascii	"// library uses (including the right inline namespace), othe"
	.ascii	"rwise they won't be\n// picked up by other functions in the "
	.ascii	"standard library (e.g. functions in\n// <complex>).  Thus th"
	.ascii	"e ugliness below.\n#ifdef _LIBCPP_BEGIN_NAMESPACE_STD\n_LIBC"
	.ascii	"PP_BEGIN_NAMESPACE_STD\n#else\nnamespace std {\n#ifdef _GLIB"
	.ascii	"CXX_BEGIN_NAMESPACE_VERSION\n_GLIBCXX_BEGIN_NAMESPACE_VERSIO"
	.ascii	"N\n#endif\n#endif\n\n// Pull the new overloads we defined ab"
	.ascii	"ove into namespace std.\nusing ::acos;\nusing ::acosh;\nusin"
	.ascii	"g ::asin;\nusing ::asinh;\nusing ::atan;\nusing ::atan2;\nus"
	.ascii	"ing ::atanh;\nusing ::cbrt;\nusing ::ceil;\nusing ::copysign"
	.ascii	";\nusing ::cos;\nusing ::cosh;\nusing ::erf;\nusing ::erfc;\n"
	.ascii	"using ::exp;\nusing ::exp2;\nusing ::expm1;\nusing ::fabs;\n"
	.ascii	"using ::fdim;\nusing ::floor;\nusing ::fma;\nusing ::fmax;\n"
	.ascii	"using ::fmin;\nusing ::fmod;\nusing ::fpclassify;\nusing ::f"
	.ascii	"rexp;\nusing ::hypot;\nusing ::ilogb;\nusing ::isfinite;\nus"
	.ascii	"ing ::isgreater;\nusing ::isgreaterequal;\nusing ::isless;\n"
	.ascii	"using ::islessequal;\nusing ::islessgreater;\nusing ::isnorm"
	.ascii	"al;\nusing ::isunordered;\nusing ::ldexp;\nusing ::lgamma;\n"
	.ascii	"using ::llrint;\nusing ::llround;\nusing ::log;\nusing ::log"
	.ascii	"10;\nusing ::log1p;\nusing ::log2;\nusing ::logb;\nusing ::l"
	.ascii	"rint;\nusing ::lround;\nusing ::nearbyint;\nusing ::nextafte"
	.ascii	"r;\nusing ::nexttoward;\nusing ::pow;\nusing ::remainder;\nu"
	.ascii	"sing ::remquo;\nusing ::rint;\nusing ::round;\n"
	.ascii	"using ::scalbln;\nusing ::scalbn;\nusing ::signbit;\nusing :"
	.ascii	":sin;\nusing ::sinh;\nusing ::sqrt;\nusing ::tan;\nusing ::t"
	.ascii	"anh;\nusing ::tgamma;\nusing ::trunc;\n\n// Well this is fun"
	.ascii	": We need to pull these symbols in for libc++, but we can't\n"
	.ascii	"// pull them in with libstdc++, because its ::isinf and ::is"
	.ascii	"nan are different\n// than its std::isinf and std::isnan.\n#"
	.ascii	"ifndef __GLIBCXX__\nusing ::isinf;\nusing ::isnan;\n#endif\n"
	.ascii	"\n// Finally, pull the \"foobarf\" functions that CUDA defin"
	.ascii	"es in its headers into\n// namespace std.\nusing ::acosf;\nu"
	.ascii	"sing ::acoshf;\nusing ::asinf;\nusing ::asinhf;\nusing ::ata"
	.ascii	"n2f;\nusing ::atanf;\nusing ::atanhf;\nusing ::cbrtf;\nusing"
	.ascii	" ::ceilf;\nusing ::copysignf;\nusing ::cosf;\nusing ::coshf;"
	.ascii	"\nusing ::erfcf;\nusing ::erff;\nusing ::exp2f;\nusing ::exp"
	.ascii	"f;\nusing ::expm1f;\nusing ::fabsf;\nusing ::fdimf;\nusing :"
	.ascii	":floorf;\nusing ::fmaf;\nusing ::fmaxf;\nusing ::fminf;\nusi"
	.ascii	"ng ::fmodf;\nusing ::frexpf;\nusing ::hypotf;\nusing ::ilogb"
	.ascii	"f;\nusing ::ldexpf;\nusing ::lgammaf;\nusing ::llrintf;\nusi"
	.ascii	"ng ::llroundf;\nusing ::log10f;\nusing ::log1pf;\nusing ::lo"
	.ascii	"g2f;\nusing ::logbf;\nusing ::logf;\nusing ::lrintf;\nusing "
	.ascii	"::lroundf;\nusing ::modff;\nusing ::nearbyintf;\nusing ::nex"
	.ascii	"tafterf;\nusing ::nexttowardf;\nusing ::nexttowardf;\nusing "
	.ascii	"::powf;\nusing ::remainderf;\nusing ::remquof;\nusing ::rint"
	.ascii	"f;\nusing ::roundf;\nusing ::scalblnf;\nusing ::scalbnf;\nus"
	.ascii	"ing ::sinf;\nusing ::sinhf;\nusing ::sqrtf;\nusing ::tanf;\n"
	.ascii	"using ::tanhf;\nusing ::tgammaf;\nusing ::truncf;\n\n#ifdef "
	.ascii	"_LIBCPP_END_NAMESPACE_STD\n_LIBCPP_END_NAMESPACE_STD\n#else\n"
	.ascii	"#ifdef _GLIBCXX_BEGIN_NAMESPACE_VERSION\n_GLIBCXX_END_NAMESP"
	.ascii	"ACE_VERSION\n#endif\n} // namespace std\n#endif\n\n#undef __"
	.ascii	"DEVICE__\n\n#endif\n"
	.globl	clang___clang_cuda_cmath_buf_size
	.align 4
	.type	clang___clang_cuda_cmath_buf_size, @object
	.size	clang___clang_cuda_cmath_buf_size, 4
clang___clang_cuda_cmath_buf_size:
	.long	17609
	.ident	"GCC: (Ubuntu 10.5.0-1ubuntu1~20.04) 10.5.0"
	.section	.note.GNU-stack,"",@progbits
	.section	.note.gnu.property,"a"
	.align 8
	.long	 1f - 0f
	.long	 4f - 1f
	.long	 5
0:
	.string	 "GNU"
1:
	.align 8
	.long	 0xc0000002
	.long	 3f - 2f
2:
	.long	 0x3
3:
	.align 8
4:

	.arch armv5t
	.eabi_attribute 20, 1
	.eabi_attribute 21, 1
	.eabi_attribute 23, 3
	.eabi_attribute 24, 1
	.eabi_attribute 25, 1
	.eabi_attribute 26, 2
	.eabi_attribute 30, 6
	.eabi_attribute 34, 0
	.eabi_attribute 18, 4
	.file	"330829.c"
	.text
	.global	clang___clang_cuda_cmath_buf
	.data
	.align	2
	.type	clang___clang_cuda_cmath_buf, %object
	.size	clang___clang_cuda_cmath_buf, 17609
clang___clang_cuda_cmath_buf:
	.ascii	"/*===---- __clang_cuda_cmath.h - Device-side CUDA c"
	.ascii	"math support ------------===\012 *\012 * Permission"
	.ascii	" is hereby granted, free of charge, to any person o"
	.ascii	"btaining a copy\012 * of this software and associat"
	.ascii	"ed documentation files (the \"Software\"), to deal\012"
	.ascii	" * in the Software without restriction, including w"
	.ascii	"ithout limitation the rights\012 * to use, copy, mo"
	.ascii	"dify, merge, publish, distribute, sublicense, and/o"
	.ascii	"r sell\012 * copies of the Software, and to permit "
	.ascii	"persons to whom the Software is\012 * furnished to "
	.ascii	"do so, subject to the following conditions:\012 *\012"
	.ascii	" * The above copyright notice and this permission n"
	.ascii	"otice shall be included in\012 * all copies or subs"
	.ascii	"tantial portions of the Software.\012 *\012 * THE S"
	.ascii	"OFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF "
	.ascii	"ANY KIND, EXPRESS OR\012 * IMPLIED, INCLUDING BUT N"
	.ascii	"OT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\012"
	.ascii	" * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGE"
	.ascii	"MENT. IN NO EVENT SHALL THE\012 * AUTHORS OR COPYRI"
	.ascii	"GHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTH"
	.ascii	"ER\012 * LIABILITY, WHETHER IN AN ACTION OF CONTRAC"
	.ascii	"T, TORT OR OTHERWISE, ARISING FROM,\012 * OUT OF OR"
	.ascii	" IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHE"
	.ascii	"R DEALINGS IN\012 * THE SOFTWARE.\012 *\012 *===---"
	.ascii	"---------------------------------------------------"
	.ascii	"-----------------===\012 */\012#ifndef __CLANG_CUDA"
	.ascii	"_CMATH_H__\012#define __CLANG_CUDA_CMATH_H__\012#if"
	.ascii	"ndef __CUDA__\012#error \"This file is for CUDA com"
	.ascii	"pilation only.\"\012#endif\012\012#include <limits>"
	.ascii	"\012\012// CUDA lets us use various std math functi"
	.ascii	"ons on the device side.  This file\012// works in c"
	.ascii	"oncert with __clang_cuda_math_forward_declares.h to"
	.ascii	" make this work.\012//\012// Specifically, the forw"
	.ascii	"ard-declares header declares __device__ overloads f"
	.ascii	"or\012// these functions in the global namespace, t"
	.ascii	"hen pulls them into namespace std\012// with 'using"
	.ascii	"' statements.  Then this file implements those func"
	.ascii	"tions, after\012// their implementations have been "
	.ascii	"pulled in.\012//\012// It's important that we decla"
	.ascii	"re the functions in the global namespace and pull\012"
	.ascii	"// them into namespace std with using statements, a"
	.ascii	"s opposed to simply decl"
	.ascii	"aring\012// these functions in namespace std, becau"
	.ascii	"se our device functions need to\012// overload the "
	.ascii	"standard library functions, which may be declared i"
	.ascii	"n the global\012// namespace or in std, depending o"
	.ascii	"n the degree of conformance of the stdlib\012// imp"
	.ascii	"lementation.  Declaring in the global namespace and"
	.ascii	" pulling into namespace\012// std covers all of the"
	.ascii	" known knowns.\012\012#define __DEVICE__ static __d"
	.ascii	"evice__ __inline__ __attribute__((always_inline))\012"
	.ascii	"\012__DEVICE__ long long abs(long long __n) { retur"
	.ascii	"n ::llabs(__n); }\012__DEVICE__ long abs(long __n) "
	.ascii	"{ return ::labs(__n); }\012__DEVICE__ float abs(flo"
	.ascii	"at __x) { return ::fabsf(__x); }\012__DEVICE__ doub"
	.ascii	"le abs(double __x) { return ::fabs(__x); }\012__DEV"
	.ascii	"ICE__ float acos(float __x) { return ::acosf(__x); "
	.ascii	"}\012__DEVICE__ float asin(float __x) { return ::as"
	.ascii	"inf(__x); }\012__DEVICE__ float atan(float __x) { r"
	.ascii	"eturn ::atanf(__x); }\012__DEVICE__ float atan2(flo"
	.ascii	"at __x, float __y) { return ::atan2f(__x, __y); }\012"
	.ascii	"__DEVICE__ float ceil(float __x) { return ::ceilf(_"
	.ascii	"_x); }\012__DEVICE__ float cos(float __x) { return "
	.ascii	"::cosf(__x); }\012__DEVICE__ float cosh(float __x) "
	.ascii	"{ return ::coshf(__x); }\012__DEVICE__ float exp(fl"
	.ascii	"oat __x) { return ::expf(__x); }\012__DEVICE__ floa"
	.ascii	"t fabs(float __x) { return ::fabsf(__x); }\012__DEV"
	.ascii	"ICE__ float floor(float __x) { return ::floorf(__x)"
	.ascii	"; }\012__DEVICE__ float fmod(float __x, float __y) "
	.ascii	"{ return ::fmodf(__x, __y); }\012__DEVICE__ int fpc"
	.ascii	"lassify(float __x) {\012  return __builtin_fpclassi"
	.ascii	"fy(FP_NAN, FP_INFINITE, FP_NORMAL, FP_SUBNORMAL,\012"
	.ascii	"                              FP_ZERO, __x);\012}\012"
	.ascii	"__DEVICE__ int fpclassify(double __x) {\012  return"
	.ascii	" __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMA"
	.ascii	"L, FP_SUBNORMAL,\012                              F"
	.ascii	"P_ZERO, __x);\012}\012__DEVICE__ float frexp(float "
	.ascii	"__arg, int *__exp) {\012  return ::frexpf(__arg, __"
	.ascii	"exp);\012}\012\012// For inscrutable reasons, the C"
	.ascii	"UDA headers define these functions for us on\012// "
	.ascii	"Windows.\012#ifndef _MSC_VER\012__DEVICE__ bool isi"
	.ascii	"nf(float __x) { return ::__isinff(__x); }\012__DEVI"
	.ascii	"CE__ bool isinf(double __x) { return ::__isinf(__x)"
	.ascii	"; }\012__DEVICE__ bool is"
	.ascii	"finite(float __x) { return ::__finitef(__x); }\012/"
	.ascii	"/ For inscrutable reasons, __finite(), the double-p"
	.ascii	"recision version of\012// __finitef, does not exist"
	.ascii	" when compiling for MacOS.  __isfinited is availabl"
	.ascii	"e\012// everywhere and is just as good.\012__DEVICE"
	.ascii	"__ bool isfinite(double __x) { return ::__isfinited"
	.ascii	"(__x); }\012__DEVICE__ bool isnan(float __x) { retu"
	.ascii	"rn ::__isnanf(__x); }\012__DEVICE__ bool isnan(doub"
	.ascii	"le __x) { return ::__isnan(__x); }\012#endif\012\012"
	.ascii	"__DEVICE__ bool isgreater(float __x, float __y) {\012"
	.ascii	"  return __builtin_isgreater(__x, __y);\012}\012__D"
	.ascii	"EVICE__ bool isgreater(double __x, double __y) {\012"
	.ascii	"  return __builtin_isgreater(__x, __y);\012}\012__D"
	.ascii	"EVICE__ bool isgreaterequal(float __x, float __y) {"
	.ascii	"\012  return __builtin_isgreaterequal(__x, __y);\012"
	.ascii	"}\012__DEVICE__ bool isgreaterequal(double __x, dou"
	.ascii	"ble __y) {\012  return __builtin_isgreaterequal(__x"
	.ascii	", __y);\012}\012__DEVICE__ bool isless(float __x, f"
	.ascii	"loat __y) {\012  return __builtin_isless(__x, __y);"
	.ascii	"\012}\012__DEVICE__ bool isless(double __x, double "
	.ascii	"__y) {\012  return __builtin_isless(__x, __y);\012}"
	.ascii	"\012__DEVICE__ bool islessequal(float __x, float __"
	.ascii	"y) {\012  return __builtin_islessequal(__x, __y);\012"
	.ascii	"}\012__DEVICE__ bool islessequal(double __x, double"
	.ascii	" __y) {\012  return __builtin_islessequal(__x, __y)"
	.ascii	";\012}\012__DEVICE__ bool islessgreater(float __x, "
	.ascii	"float __y) {\012  return __builtin_islessgreater(__"
	.ascii	"x, __y);\012}\012__DEVICE__ bool islessgreater(doub"
	.ascii	"le __x, double __y) {\012  return __builtin_islessg"
	.ascii	"reater(__x, __y);\012}\012__DEVICE__ bool isnormal("
	.ascii	"float __x) { return __builtin_isnormal(__x); }\012_"
	.ascii	"_DEVICE__ bool isnormal(double __x) { return __buil"
	.ascii	"tin_isnormal(__x); }\012__DEVICE__ bool isunordered"
	.ascii	"(float __x, float __y) {\012  return __builtin_isun"
	.ascii	"ordered(__x, __y);\012}\012__DEVICE__ bool isunorde"
	.ascii	"red(double __x, double __y) {\012  return __builtin"
	.ascii	"_isunordered(__x, __y);\012}\012__DEVICE__ float ld"
	.ascii	"exp(float __arg, int __exp) {\012  return ::ldexpf("
	.ascii	"__arg, __exp);\012}\012__DEVICE__ float log(float _"
	.ascii	"_x) { return ::logf(__x); }\012__DEVICE__ float log"
	.ascii	"10(float __x) { return ::log10f(__x); }\012__DEVICE"
	.ascii	"__ float modf(float __x, float *__iptr) { return ::"
	.ascii	"modff(_"
	.ascii	"_x, __iptr); }\012__DEVICE__ float nexttoward(float"
	.ascii	" __from, double __to) {\012  return __builtin_nextt"
	.ascii	"owardf(__from, __to);\012}\012__DEVICE__ double nex"
	.ascii	"ttoward(double __from, double __to) {\012  return _"
	.ascii	"_builtin_nexttoward(__from, __to);\012}\012__DEVICE"
	.ascii	"__ float nexttowardf(float __from, double __to) {\012"
	.ascii	"  return __builtin_nexttowardf(__from, __to);\012}\012"
	.ascii	"__DEVICE__ float pow(float __base, float __exp) {\012"
	.ascii	"  return ::powf(__base, __exp);\012}\012__DEVICE__ "
	.ascii	"float pow(float __base, int __iexp) {\012  return :"
	.ascii	":powif(__base, __iexp);\012}\012__DEVICE__ double p"
	.ascii	"ow(double __base, int __iexp) {\012  return ::powi("
	.ascii	"__base, __iexp);\012}\012__DEVICE__ bool signbit(fl"
	.ascii	"oat __x) { return ::__signbitf(__x); }\012__DEVICE_"
	.ascii	"_ bool signbit(double __x) { return ::__signbitd(__"
	.ascii	"x); }\012__DEVICE__ float sin(float __x) { return :"
	.ascii	":sinf(__x); }\012__DEVICE__ float sinh(float __x) {"
	.ascii	" return ::sinhf(__x); }\012__DEVICE__ float sqrt(fl"
	.ascii	"oat __x) { return ::sqrtf(__x); }\012__DEVICE__ flo"
	.ascii	"at tan(float __x) { return ::tanf(__x); }\012__DEVI"
	.ascii	"CE__ float tanh(float __x) { return ::tanhf(__x); }"
	.ascii	"\012\012// Now we've defined everything we promised"
	.ascii	" we'd define in\012// __clang_cuda_math_forward_dec"
	.ascii	"lares.h.  We need to do two additional things to\012"
	.ascii	"// fix up our math functions.\012//\012// 1) Define"
	.ascii	" __device__ overloads for e.g. sin(int).  The CUDA "
	.ascii	"headers define\012//    only sin(float) and sin(dou"
	.ascii	"ble), which means that e.g. sin(0) is\012//    ambi"
	.ascii	"guous.\012//\012// 2) Pull the __device__ overloads"
	.ascii	" of \"foobarf\" math functions into namespace\012//"
	.ascii	"    std.  These are defined in the CUDA headers in "
	.ascii	"the global namespace,\012//    independent of every"
	.ascii	"thing else we've done here.\012\012// We can't use "
	.ascii	"std::enable_if, because we want to be pre-C++11 com"
	.ascii	"patible.  But\012// we go ahead and unconditionally"
	.ascii	" define functions that are only available when\012/"
	.ascii	"/ compiling for C++11 to match the behavior of the "
	.ascii	"CUDA headers.\012template<bool __B, class __T = voi"
	.ascii	"d>\012struct __clang_cuda_enable_if {};\012\012temp"
	.ascii	"late <class __T> struct __clang_cuda_enable_if<true"
	.ascii	", __T> {\012  typedef __T type;\012};\012\012// Def"
	.ascii	"ines an overload of __fn that accepts one integral"
	.ascii	" argument, calls\012// __fn((double)x), and returns"
	.ascii	" __retty.\012#define __CUDA_CLANG_FN_INTEGER_OVERLO"
	.ascii	"AD_1(__retty, __fn)                      \\\012  te"
	.ascii	"mplate <typename __T>                              "
	.ascii	"                        \\\012  __DEVICE__         "
	.ascii	"                                                   "
	.ascii	"       \\\012      typename __clang_cuda_enable_if<"
	.ascii	"std::numeric_limits<__T>::is_integer,    \\\012    "
	.ascii	"                                  __retty>::type   "
	.ascii	"                        \\\012      __fn(__T __x) {"
	.ascii	"                                                   "
	.ascii	"       \\\012    return ::__fn((double)__x);       "
	.ascii	"                                         \\\012  }\012"
	.ascii	"\012// Defines an overload of __fn that accepts one"
	.ascii	" two arithmetic arguments, calls\012// __fn((double"
	.ascii	")x, (double)y), and returns a double.\012//\012// N"
	.ascii	"ote this is different from OVERLOAD_1, which genera"
	.ascii	"tes an overload that\012// accepts only *integral* "
	.ascii	"arguments.\012#define __CUDA_CLANG_FN_INTEGER_OVERL"
	.ascii	"OAD_2(__retty, __fn)                      \\\012  t"
	.ascii	"emplate <typename __T1, typename __T2>             "
	.ascii	"                         \\\012  __DEVICE__ typenam"
	.ascii	"e __clang_cuda_enable_if<                          "
	.ascii	"        \\\012      std::numeric_limits<__T1>::is_s"
	.ascii	"pecialized &&                             \\\012   "
	.ascii	"       std::numeric_limits<__T2>::is_specialized,  "
	.ascii	"                         \\\012      __retty>::type"
	.ascii	"                                                   "
	.ascii	"        \\\012  __fn(__T1 __x, __T2 __y) {         "
	.ascii	"                                          \\\012   "
	.ascii	" return __fn((double)__x, (double)__y);            "
	.ascii	"                         \\\012  }\012\012__CUDA_CL"
	.ascii	"ANG_FN_INTEGER_OVERLOAD_1(double, acos)\012__CUDA_C"
	.ascii	"LANG_FN_INTEGER_OVERLOAD_1(double, acosh)\012__CUDA"
	.ascii	"_CLANG_FN_INTEGER_OVERLOAD_1(double, asin)\012__CUD"
	.ascii	"A_CLANG_FN_INTEGER_OVERLOAD_1(double, asinh)\012__C"
	.ascii	"UDA_CLANG_FN_INTEGER_OVERLOAD_1(double, atan)\012__"
	.ascii	"CUDA_CLANG_FN_INTEGER_OVERLOAD_2(double, atan2);\012"
	.ascii	"__CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, atanh)\012"
	.ascii	"__CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, cbrt)\012"
	.ascii	"__CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, ceil)\012"
	.ascii	"__CUDA_CLANG_FN_INTEG"
	.ascii	"ER_OVERLOAD_2(double, copysign);\012__CUDA_CLANG_FN"
	.ascii	"_INTEGER_OVERLOAD_1(double, cos)\012__CUDA_CLANG_FN"
	.ascii	"_INTEGER_OVERLOAD_1(double, cosh)\012__CUDA_CLANG_F"
	.ascii	"N_INTEGER_OVERLOAD_1(double, erf)\012__CUDA_CLANG_F"
	.ascii	"N_INTEGER_OVERLOAD_1(double, erfc)\012__CUDA_CLANG_"
	.ascii	"FN_INTEGER_OVERLOAD_1(double, exp)\012__CUDA_CLANG_"
	.ascii	"FN_INTEGER_OVERLOAD_1(double, exp2)\012__CUDA_CLANG"
	.ascii	"_FN_INTEGER_OVERLOAD_1(double, expm1)\012__CUDA_CLA"
	.ascii	"NG_FN_INTEGER_OVERLOAD_1(double, fabs)\012__CUDA_CL"
	.ascii	"ANG_FN_INTEGER_OVERLOAD_2(double, fdim);\012__CUDA_"
	.ascii	"CLANG_FN_INTEGER_OVERLOAD_1(double, floor)\012__CUD"
	.ascii	"A_CLANG_FN_INTEGER_OVERLOAD_2(double, fmax);\012__C"
	.ascii	"UDA_CLANG_FN_INTEGER_OVERLOAD_2(double, fmin);\012_"
	.ascii	"_CUDA_CLANG_FN_INTEGER_OVERLOAD_2(double, fmod);\012"
	.ascii	"__CUDA_CLANG_FN_INTEGER_OVERLOAD_1(int, fpclassify)"
	.ascii	"\012__CUDA_CLANG_FN_INTEGER_OVERLOAD_2(double, hypo"
	.ascii	"t);\012__CUDA_CLANG_FN_INTEGER_OVERLOAD_1(int, ilog"
	.ascii	"b)\012__CUDA_CLANG_FN_INTEGER_OVERLOAD_1(bool, isfi"
	.ascii	"nite)\012__CUDA_CLANG_FN_INTEGER_OVERLOAD_2(bool, i"
	.ascii	"sgreater);\012__CUDA_CLANG_FN_INTEGER_OVERLOAD_2(bo"
	.ascii	"ol, isgreaterequal);\012__CUDA_CLANG_FN_INTEGER_OVE"
	.ascii	"RLOAD_1(bool, isinf);\012__CUDA_CLANG_FN_INTEGER_OV"
	.ascii	"ERLOAD_2(bool, isless);\012__CUDA_CLANG_FN_INTEGER_"
	.ascii	"OVERLOAD_2(bool, islessequal);\012__CUDA_CLANG_FN_I"
	.ascii	"NTEGER_OVERLOAD_2(bool, islessgreater);\012__CUDA_C"
	.ascii	"LANG_FN_INTEGER_OVERLOAD_1(bool, isnan);\012__CUDA_"
	.ascii	"CLANG_FN_INTEGER_OVERLOAD_1(bool, isnormal)\012__CU"
	.ascii	"DA_CLANG_FN_INTEGER_OVERLOAD_2(bool, isunordered);\012"
	.ascii	"__CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, lgamma)\012"
	.ascii	"__CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, log)\012"
	.ascii	"__CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, log10)\012"
	.ascii	"__CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, log1p)\012"
	.ascii	"__CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, log2)\012"
	.ascii	"__CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, logb)\012"
	.ascii	"__CUDA_CLANG_FN_INTEGER_OVERLOAD_1(long long, llrin"
	.ascii	"t)\012__CUDA_CLANG_FN_INTEGER_OVERLOAD_1(long long,"
	.ascii	" llround)\012__CUDA_CLANG_FN_INTEGER_OVERLOAD_1(lon"
	.ascii	"g, lrint)\012__CUDA_CLANG_FN_INTEGER_OVERLOAD_1(lon"
	.ascii	"g, lround)\012__CUDA_CLANG_FN_INTEGER_OVERLOAD_1(do"
	.ascii	"uble, nearbyint);\012__CUDA_CLANG_FN_INTEGER_OVERLO"
	.ascii	"AD_2(double, nextafter);\012__CUDA_CLANG_FN_INTEGER"
	.ascii	"_OVERLOAD_2(d"
	.ascii	"ouble, pow);\012__CUDA_CLANG_FN_INTEGER_OVERLOAD_2("
	.ascii	"double, remainder);\012__CUDA_CLANG_FN_INTEGER_OVER"
	.ascii	"LOAD_1(double, rint);\012__CUDA_CLANG_FN_INTEGER_OV"
	.ascii	"ERLOAD_1(double, round);\012__CUDA_CLANG_FN_INTEGER"
	.ascii	"_OVERLOAD_1(bool, signbit)\012__CUDA_CLANG_FN_INTEG"
	.ascii	"ER_OVERLOAD_1(double, sin)\012__CUDA_CLANG_FN_INTEG"
	.ascii	"ER_OVERLOAD_1(double, sinh)\012__CUDA_CLANG_FN_INTE"
	.ascii	"GER_OVERLOAD_1(double, sqrt)\012__CUDA_CLANG_FN_INT"
	.ascii	"EGER_OVERLOAD_1(double, tan)\012__CUDA_CLANG_FN_INT"
	.ascii	"EGER_OVERLOAD_1(double, tanh)\012__CUDA_CLANG_FN_IN"
	.ascii	"TEGER_OVERLOAD_1(double, tgamma)\012__CUDA_CLANG_FN"
	.ascii	"_INTEGER_OVERLOAD_1(double, trunc);\012\012#undef _"
	.ascii	"_CUDA_CLANG_FN_INTEGER_OVERLOAD_1\012#undef __CUDA_"
	.ascii	"CLANG_FN_INTEGER_OVERLOAD_2\012\012// Overloads for"
	.ascii	" functions that don't match the patterns expected b"
	.ascii	"y\012// __CUDA_CLANG_FN_INTEGER_OVERLOAD_{1,2}.\012"
	.ascii	"template <typename __T1, typename __T2, typename __"
	.ascii	"T3>\012__DEVICE__ typename __clang_cuda_enable_if<\012"
	.ascii	"    std::numeric_limits<__T1>::is_specialized &&\012"
	.ascii	"        std::numeric_limits<__T2>::is_specialized &"
	.ascii	"&\012        std::numeric_limits<__T3>::is_speciali"
	.ascii	"zed,\012    double>::type\012fma(__T1 __x, __T2 __y"
	.ascii	", __T3 __z) {\012  return std::fma((double)__x, (do"
	.ascii	"uble)__y, (double)__z);\012}\012\012template <typen"
	.ascii	"ame __T>\012__DEVICE__ typename __clang_cuda_enable"
	.ascii	"_if<std::numeric_limits<__T>::is_integer,\012      "
	.ascii	"                                     double>::type\012"
	.ascii	"frexp(__T __x, int *__exp) {\012  return std::frexp"
	.ascii	"((double)__x, __exp);\012}\012\012template <typenam"
	.ascii	"e __T>\012__DEVICE__ typename __clang_cuda_enable_i"
	.ascii	"f<std::numeric_limits<__T>::is_integer,\012        "
	.ascii	"                                   double>::type\012"
	.ascii	"ldexp(__T __x, int __exp) {\012  return std::ldexp("
	.ascii	"(double)__x, __exp);\012}\012\012template <typename"
	.ascii	" __T>\012__DEVICE__ typename __clang_cuda_enable_if"
	.ascii	"<std::numeric_limits<__T>::is_integer,\012         "
	.ascii	"                                  double>::type\012"
	.ascii	"nexttoward(__T __from, double __to) {\012  return s"
	.ascii	"td::nexttoward((double)__from, __to);\012}\012\012t"
	.ascii	"emplate <typename __T1, typename __T2>\012__DEVICE_"
	.ascii	"_ typename __clang_cuda_enable_if<\012    std::nume"
	.ascii	"ric_limits<__T1>::is_specialized &&\012        std:"
	.ascii	":numer"
	.ascii	"ic_limits<__T2>::is_specialized,\012    double>::ty"
	.ascii	"pe\012remquo(__T1 __x, __T2 __y, int *__quo) {\012 "
	.ascii	" return std::remquo((double)__x, (double)__y, __quo"
	.ascii	");\012}\012\012template <typename __T>\012__DEVICE_"
	.ascii	"_ typename __clang_cuda_enable_if<std::numeric_limi"
	.ascii	"ts<__T>::is_integer,\012                           "
	.ascii	"                double>::type\012scalbln(__T __x, l"
	.ascii	"ong __exp) {\012  return std::scalbln((double)__x, "
	.ascii	"__exp);\012}\012\012template <typename __T>\012__DE"
	.ascii	"VICE__ typename __clang_cuda_enable_if<std::numeric"
	.ascii	"_limits<__T>::is_integer,\012                      "
	.ascii	"                     double>::type\012scalbn(__T __"
	.ascii	"x, int __exp) {\012  return std::scalbn((double)__x"
	.ascii	", __exp);\012}\012\012// We need to define these ov"
	.ascii	"erloads in exactly the namespace our standard\012//"
	.ascii	" library uses (including the right inline namespace"
	.ascii	"), otherwise they won't be\012// picked up by other"
	.ascii	" functions in the standard library (e.g. functions "
	.ascii	"in\012// <complex>).  Thus the ugliness below.\012#"
	.ascii	"ifdef _LIBCPP_BEGIN_NAMESPACE_STD\012_LIBCPP_BEGIN_"
	.ascii	"NAMESPACE_STD\012#else\012namespace std {\012#ifdef"
	.ascii	" _GLIBCXX_BEGIN_NAMESPACE_VERSION\012_GLIBCXX_BEGIN"
	.ascii	"_NAMESPACE_VERSION\012#endif\012#endif\012\012// Pu"
	.ascii	"ll the new overloads we defined above into namespac"
	.ascii	"e std.\012using ::acos;\012using ::acosh;\012using "
	.ascii	"::asin;\012using ::asinh;\012using ::atan;\012using"
	.ascii	" ::atan2;\012using ::atanh;\012using ::cbrt;\012usi"
	.ascii	"ng ::ceil;\012using ::copysign;\012using ::cos;\012"
	.ascii	"using ::cosh;\012using ::erf;\012using ::erfc;\012u"
	.ascii	"sing ::exp;\012using ::exp2;\012using ::expm1;\012u"
	.ascii	"sing ::fabs;\012using ::fdim;\012using ::floor;\012"
	.ascii	"using ::fma;\012using ::fmax;\012using ::fmin;\012u"
	.ascii	"sing ::fmod;\012using ::fpclassify;\012using ::frex"
	.ascii	"p;\012using ::hypot;\012using ::ilogb;\012using ::i"
	.ascii	"sfinite;\012using ::isgreater;\012using ::isgreater"
	.ascii	"equal;\012using ::isless;\012using ::islessequal;\012"
	.ascii	"using ::islessgreater;\012using ::isnormal;\012usin"
	.ascii	"g ::isunordered;\012using ::ldexp;\012using ::lgamm"
	.ascii	"a;\012using ::llrint;\012using ::llround;\012using "
	.ascii	"::log;\012using ::log10;\012using ::log1p;\012using"
	.ascii	" ::log2;\012using ::logb;\012using ::lrint;\012usin"
	.ascii	"g ::lround;\012using ::nearbyint;\012using ::nextaf"
	.ascii	"ter;\012using ::nexttoward;\012using ::pow;\012usin"
	.ascii	"g ::remainder;\012using ::remquo;\012using ::rint;\012"
	.ascii	"using ::round;\012"
	.ascii	"using ::scalbln;\012using ::scalbn;\012using ::sign"
	.ascii	"bit;\012using ::sin;\012using ::sinh;\012using ::sq"
	.ascii	"rt;\012using ::tan;\012using ::tanh;\012using ::tga"
	.ascii	"mma;\012using ::trunc;\012\012// Well this is fun: "
	.ascii	"We need to pull these symbols in for libc++, but we"
	.ascii	" can't\012// pull them in with libstdc++, because i"
	.ascii	"ts ::isinf and ::isnan are different\012// than its"
	.ascii	" std::isinf and std::isnan.\012#ifndef __GLIBCXX__\012"
	.ascii	"using ::isinf;\012using ::isnan;\012#endif\012\012/"
	.ascii	"/ Finally, pull the \"foobarf\" functions that CUDA"
	.ascii	" defines in its headers into\012// namespace std.\012"
	.ascii	"using ::acosf;\012using ::acoshf;\012using ::asinf;"
	.ascii	"\012using ::asinhf;\012using ::atan2f;\012using ::a"
	.ascii	"tanf;\012using ::atanhf;\012using ::cbrtf;\012using"
	.ascii	" ::ceilf;\012using ::copysignf;\012using ::cosf;\012"
	.ascii	"using ::coshf;\012using ::erfcf;\012using ::erff;\012"
	.ascii	"using ::exp2f;\012using ::expf;\012using ::expm1f;\012"
	.ascii	"using ::fabsf;\012using ::fdimf;\012using ::floorf;"
	.ascii	"\012using ::fmaf;\012using ::fmaxf;\012using ::fmin"
	.ascii	"f;\012using ::fmodf;\012using ::frexpf;\012using ::"
	.ascii	"hypotf;\012using ::ilogbf;\012using ::ldexpf;\012us"
	.ascii	"ing ::lgammaf;\012using ::llrintf;\012using ::llrou"
	.ascii	"ndf;\012using ::log10f;\012using ::log1pf;\012using"
	.ascii	" ::log2f;\012using ::logbf;\012using ::logf;\012usi"
	.ascii	"ng ::lrintf;\012using ::lroundf;\012using ::modff;\012"
	.ascii	"using ::nearbyintf;\012using ::nextafterf;\012using"
	.ascii	" ::nexttowardf;\012using ::nexttowardf;\012using ::"
	.ascii	"powf;\012using ::remainderf;\012using ::remquof;\012"
	.ascii	"using ::rintf;\012using ::roundf;\012using ::scalbl"
	.ascii	"nf;\012using ::scalbnf;\012using ::sinf;\012using :"
	.ascii	":sinhf;\012using ::sqrtf;\012using ::tanf;\012using"
	.ascii	" ::tanhf;\012using ::tgammaf;\012using ::truncf;\012"
	.ascii	"\012#ifdef _LIBCPP_END_NAMESPACE_STD\012_LIBCPP_END"
	.ascii	"_NAMESPACE_STD\012#else\012#ifdef _GLIBCXX_BEGIN_NA"
	.ascii	"MESPACE_VERSION\012_GLIBCXX_END_NAMESPACE_VERSION\012"
	.ascii	"#endif\012} // namespace std\012#endif\012\012#unde"
	.ascii	"f __DEVICE__\012\012#endif\012"
	.global	clang___clang_cuda_cmath_buf_size
	.align	2
	.type	clang___clang_cuda_cmath_buf_size, %object
	.size	clang___clang_cuda_cmath_buf_size, 4
clang___clang_cuda_cmath_buf_size:
	.word	17609
	.ident	"GCC: (Ubuntu 9.4.0-1ubuntu1~20.04.2) 9.4.0"
	.section	.note.GNU-stack,"",%progbits
