rmontanana/BayesNet
rmontanana/BayesNet
1
0
Fork 0
Code Issues 2 Pull Requests Packages Projects Releases 3 Wiki Activity
3c7382a93a
BayesNet/html/usr/include/c++/13/cmath.gcov.html

3781 lines
376 KiB
HTML
Raw Normal View History

Enhance tests coverage and report output
2024-04-30 12:00:24 +00:00
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html lang="en">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>LCOV - coverage.info - usr/include/c++/13/cmath</title>
<link rel="stylesheet" type="text/css" href="../../../../gcov.css">
</head>
<body>
<table width="100%" border=0 cellspacing=0 cellpadding=0>
<tr><td class="title">LCOV - code coverage report</td></tr>
<tr><td class="ruler"><img src="../../../../glass.png" width=3 height=3 alt=""></td></tr>
<tr>
<td width="100%">
<table cellpadding=1 border=0 width="100%">
<tr>
<td width="10%" class="headerItem">Current view:</td>
<td width="10%" class="headerValue"><a href="../../../../index.html">top level</a> - <a href="index.html">/usr/include/c++/13</a> - cmath<span style="font-size: 80%;"> (source / <a href="cmath.func-c.html">functions</a>)</span></td>
<td width="5%"></td>
<td width="5%"></td>
<td width="5%" class="headerCovTableHead">Coverage</td>
<td width="5%" class="headerCovTableHead" title="Covered + Uncovered code">Total</td>
<td width="5%" class="headerCovTableHead" title="Exercised code only">Hit</td>
</tr>
<tr>
<td class="headerItem">Test:</td>
<td class="headerValue">coverage.info</td>
<td></td>
<td class="headerItem">Lines:</td>
<td class="headerCovTableEntryLo">66.7&nbsp;%</td>
<td class="headerCovTableEntry">6</td>
<td class="headerCovTableEntry">4</td>
</tr>
<tr>
<td class="headerItem">Test Date:</td>
<td class="headerValue">2024-04-30 13:17:26</td>
<td></td>
<td class="headerItem">Functions:</td>
<td class="headerCovTableEntryLo">66.7&nbsp;%</td>
<td class="headerCovTableEntry">3</td>
<td class="headerCovTableEntry">2</td>
</tr>
<tr><td><img src="../../../../glass.png" width=3 height=3 alt=""></td></tr>
</table>
</td>
</tr>
<tr><td class="ruler"><img src="../../../../glass.png" width=3 height=3 alt=""></td></tr>
</table>
<table cellpadding=0 cellspacing=0 border=0>
<tr>
<td><br></td>
</tr>
<tr>
<td>
<pre class="sourceHeading"> Line data Source code</pre>
<pre class="source">
<span id="L1"><span class="lineNum"> 1</span> : // -*- C++ -*- C forwarding header.</span>
<span id="L2"><span class="lineNum"> 2</span> : </span>
<span id="L3"><span class="lineNum"> 3</span> : // Copyright (C) 1997-2023 Free Software Foundation, Inc.</span>
<span id="L4"><span class="lineNum"> 4</span> : //</span>
<span id="L5"><span class="lineNum"> 5</span> : // This file is part of the GNU ISO C++ Library. This library is free</span>
<span id="L6"><span class="lineNum"> 6</span> : // software; you can redistribute it and/or modify it under the</span>
<span id="L7"><span class="lineNum"> 7</span> : // terms of the GNU General Public License as published by the</span>
<span id="L8"><span class="lineNum"> 8</span> : // Free Software Foundation; either version 3, or (at your option)</span>
<span id="L9"><span class="lineNum"> 9</span> : // any later version.</span>
<span id="L10"><span class="lineNum"> 10</span> : </span>
<span id="L11"><span class="lineNum"> 11</span> : // This library is distributed in the hope that it will be useful,</span>
<span id="L12"><span class="lineNum"> 12</span> : // but WITHOUT ANY WARRANTY; without even the implied warranty of</span>
<span id="L13"><span class="lineNum"> 13</span> : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the</span>
<span id="L14"><span class="lineNum"> 14</span> : // GNU General Public License for more details.</span>
<span id="L15"><span class="lineNum"> 15</span> : </span>
<span id="L16"><span class="lineNum"> 16</span> : // Under Section 7 of GPL version 3, you are granted additional</span>
<span id="L17"><span class="lineNum"> 17</span> : // permissions described in the GCC Runtime Library Exception, version</span>
<span id="L18"><span class="lineNum"> 18</span> : // 3.1, as published by the Free Software Foundation.</span>
<span id="L19"><span class="lineNum"> 19</span> : </span>
<span id="L20"><span class="lineNum"> 20</span> : // You should have received a copy of the GNU General Public License and</span>
<span id="L21"><span class="lineNum"> 21</span> : // a copy of the GCC Runtime Library Exception along with this program;</span>
<span id="L22"><span class="lineNum"> 22</span> : // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see</span>
<span id="L23"><span class="lineNum"> 23</span> : // &lt;http://www.gnu.org/licenses/&gt;.</span>
<span id="L24"><span class="lineNum"> 24</span> : </span>
<span id="L25"><span class="lineNum"> 25</span> : /** @file include/cmath</span>
<span id="L26"><span class="lineNum"> 26</span> : * This is a Standard C++ Library file. You should @c \#include this file</span>
<span id="L27"><span class="lineNum"> 27</span> : * in your programs, rather than any of the @a *.h implementation files.</span>
<span id="L28"><span class="lineNum"> 28</span> : *</span>
<span id="L29"><span class="lineNum"> 29</span> : * This is the C++ version of the Standard C Library header @c math.h,</span>
<span id="L30"><span class="lineNum"> 30</span> : * and its contents are (mostly) the same as that header, but are all</span>
<span id="L31"><span class="lineNum"> 31</span> : * contained in the namespace @c std (except for names which are defined</span>
<span id="L32"><span class="lineNum"> 32</span> : * as macros in C).</span>
<span id="L33"><span class="lineNum"> 33</span> : */</span>
<span id="L34"><span class="lineNum"> 34</span> : </span>
<span id="L35"><span class="lineNum"> 35</span> : //</span>
<span id="L36"><span class="lineNum"> 36</span> : // ISO C++ 14882: 26.5 C library</span>
<span id="L37"><span class="lineNum"> 37</span> : //</span>
<span id="L38"><span class="lineNum"> 38</span> : </span>
<span id="L39"><span class="lineNum"> 39</span> : #pragma GCC system_header</span>
<span id="L40"><span class="lineNum"> 40</span> : </span>
<span id="L41"><span class="lineNum"> 41</span> : #include &lt;bits/requires_hosted.h&gt;</span>
<span id="L42"><span class="lineNum"> 42</span> : </span>
<span id="L43"><span class="lineNum"> 43</span> : #include &lt;bits/c++config.h&gt;</span>
<span id="L44"><span class="lineNum"> 44</span> : #include &lt;bits/cpp_type_traits.h&gt;</span>
<span id="L45"><span class="lineNum"> 45</span> : #include &lt;ext/type_traits.h&gt;</span>
<span id="L46"><span class="lineNum"> 46</span> : #define _GLIBCXX_INCLUDE_NEXT_C_HEADERS</span>
<span id="L47"><span class="lineNum"> 47</span> : #include_next &lt;math.h&gt;</span>
<span id="L48"><span class="lineNum"> 48</span> : #undef _GLIBCXX_INCLUDE_NEXT_C_HEADERS</span>
<span id="L49"><span class="lineNum"> 49</span> : #include &lt;bits/std_abs.h&gt;</span>
<span id="L50"><span class="lineNum"> 50</span> : </span>
<span id="L51"><span class="lineNum"> 51</span> : #ifndef _GLIBCXX_CMATH</span>
<span id="L52"><span class="lineNum"> 52</span> : #define _GLIBCXX_CMATH 1</span>
<span id="L53"><span class="lineNum"> 53</span> : </span>
<span id="L54"><span class="lineNum"> 54</span> : // Get rid of those macros defined in &lt;math.h&gt; in lieu of real functions.</span>
<span id="L55"><span class="lineNum"> 55</span> : #undef div</span>
<span id="L56"><span class="lineNum"> 56</span> : #undef acos</span>
<span id="L57"><span class="lineNum"> 57</span> : #undef asin</span>
<span id="L58"><span class="lineNum"> 58</span> : #undef atan</span>
<span id="L59"><span class="lineNum"> 59</span> : #undef atan2</span>
<span id="L60"><span class="lineNum"> 60</span> : #undef ceil</span>
<span id="L61"><span class="lineNum"> 61</span> : #undef cos</span>
<span id="L62"><span class="lineNum"> 62</span> : #undef cosh</span>
<span id="L63"><span class="lineNum"> 63</span> : #undef exp</span>
<span id="L64"><span class="lineNum"> 64</span> : #undef fabs</span>
<span id="L65"><span class="lineNum"> 65</span> : #undef floor</span>
<span id="L66"><span class="lineNum"> 66</span> : #undef fmod</span>
<span id="L67"><span class="lineNum"> 67</span> : #undef frexp</span>
<span id="L68"><span class="lineNum"> 68</span> : #undef ldexp</span>
<span id="L69"><span class="lineNum"> 69</span> : #undef log</span>
<span id="L70"><span class="lineNum"> 70</span> : #undef log10</span>
<span id="L71"><span class="lineNum"> 71</span> : #undef modf</span>
<span id="L72"><span class="lineNum"> 72</span> : #undef pow</span>
<span id="L73"><span class="lineNum"> 73</span> : #undef sin</span>
<span id="L74"><span class="lineNum"> 74</span> : #undef sinh</span>
<span id="L75"><span class="lineNum"> 75</span> : #undef sqrt</span>
<span id="L76"><span class="lineNum"> 76</span> : #undef tan</span>
<span id="L77"><span class="lineNum"> 77</span> : #undef tanh</span>
<span id="L78"><span class="lineNum"> 78</span> : </span>
<span id="L79"><span class="lineNum"> 79</span> : extern &quot;C++&quot;</span>
<span id="L80"><span class="lineNum"> 80</span> : {</span>
<span id="L81"><span class="lineNum"> 81</span> : namespace std _GLIBCXX_VISIBILITY(default)</span>
<span id="L82"><span class="lineNum"> 82</span> : {</span>
<span id="L83"><span class="lineNum"> 83</span> : _GLIBCXX_BEGIN_NAMESPACE_VERSION</span>
<span id="L84"><span class="lineNum"> 84</span> : </span>
<span id="L85"><span class="lineNum"> 85</span> : using ::acos;</span>
<span id="L86"><span class="lineNum"> 86</span> : </span>
<span id="L87"><span class="lineNum"> 87</span> : #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO</span>
<span id="L88"><span class="lineNum"> 88</span> : inline _GLIBCXX_CONSTEXPR float</span>
<span id="L89"><span class="lineNum"> 89</span> : acos(float __x)</span>
<span id="L90"><span class="lineNum"> 90</span> : { return __builtin_acosf(__x); }</span>
<span id="L91"><span class="lineNum"> 91</span> : </span>
<span id="L92"><span class="lineNum"> 92</span> : inline _GLIBCXX_CONSTEXPR long double</span>
<span id="L93"><span class="lineNum"> 93</span> : acos(long double __x)</span>
<span id="L94"><span class="lineNum"> 94</span> : { return __builtin_acosl(__x); }</span>
<span id="L95"><span class="lineNum"> 95</span> : #endif</span>
<span id="L96"><span class="lineNum"> 96</span> : </span>
<span id="L97"><span class="lineNum"> 97</span> : template&lt;typename _Tp&gt;</span>
<span id="L98"><span class="lineNum"> 98</span> : inline _GLIBCXX_CONSTEXPR</span>
<span id="L99"><span class="lineNum"> 99</span> : typename __gnu_cxx::__enable_if&lt;__is_integer&lt;_Tp&gt;::__value, </span>
<span id="L100"><span class="lineNum"> 100</span> : double&gt;::__type</span>
<span id="L101"><span class="lineNum"> 101</span> : acos(_Tp __x)</span>
<span id="L102"><span class="lineNum"> 102</span> : { return __builtin_acos(__x); }</span>
<span id="L103"><span class="lineNum"> 103</span> : </span>
<span id="L104"><span class="lineNum"> 104</span> : using ::asin;</span>
<span id="L105"><span class="lineNum"> 105</span> : </span>
<span id="L106"><span class="lineNum"> 106</span> : #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO</span>
<span id="L107"><span class="lineNum"> 107</span> : inline _GLIBCXX_CONSTEXPR float</span>
<span id="L108"><span class="lineNum"> 108</span> : asin(float __x)</span>
<span id="L109"><span class="lineNum"> 109</span> : { return __builtin_asinf(__x); }</span>
<span id="L110"><span class="lineNum"> 110</span> : </span>
<span id="L111"><span class="lineNum"> 111</span> : inline _GLIBCXX_CONSTEXPR long double</span>
<span id="L112"><span class="lineNum"> 112</span> : asin(long double __x)</span>
<span id="L113"><span class="lineNum"> 113</span> : { return __builtin_asinl(__x); }</span>
<span id="L114"><span class="lineNum"> 114</span> : #endif</span>
<span id="L115"><span class="lineNum"> 115</span> : </span>
<span id="L116"><span class="lineNum"> 116</span> : template&lt;typename _Tp&gt;</span>
<span id="L117"><span class="lineNum"> 117</span> : inline _GLIBCXX_CONSTEXPR</span>
<span id="L118"><span class="lineNum"> 118</span> : typename __gnu_cxx::__enable_if&lt;__is_integer&lt;_Tp&gt;::__value,</span>
<span id="L119"><span class="lineNum"> 119</span> : double&gt;::__type</span>
<span id="L120"><span class="lineNum"> 120</span> : asin(_Tp __x)</span>
<span id="L121"><span class="lineNum"> 121</span> : { return __builtin_asin(__x); }</span>
<span id="L122"><span class="lineNum"> 122</span> : </span>
<span id="L123"><span class="lineNum"> 123</span> : using ::atan;</span>
<span id="L124"><span class="lineNum"> 124</span> : </span>
<span id="L125"><span class="lineNum"> 125</span> : #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO</span>
<span id="L126"><span class="lineNum"> 126</span> : inline _GLIBCXX_CONSTEXPR float</span>
<span id="L127"><span class="lineNum"> 127</span> : atan(float __x)</span>
<span id="L128"><span class="lineNum"> 128</span> : { return __builtin_atanf(__x); }</span>
<span id="L129"><span class="lineNum"> 129</span> : </span>
<span id="L130"><span class="lineNum"> 130</span> : inline _GLIBCXX_CONSTEXPR long double</span>
<span id="L131"><span class="lineNum"> 131</span> : atan(long double __x)</span>
<span id="L132"><span class="lineNum"> 132</span> : { return __builtin_atanl(__x); }</span>
<span id="L133"><span class="lineNum"> 133</span> : #endif</span>
<span id="L134"><span class="lineNum"> 134</span> : </span>
<span id="L135"><span class="lineNum"> 135</span> : template&lt;typename _Tp&gt;</span>
<span id="L136"><span class="lineNum"> 136</span> : inline _GLIBCXX_CONSTEXPR</span>
<span id="L137"><span class="lineNum"> 137</span> : typename __gnu_cxx::__enable_if&lt;__is_integer&lt;_Tp&gt;::__value,</span>
<span id="L138"><span class="lineNum"> 138</span> : double&gt;::__type</span>
<span id="L139"><span class="lineNum"> 139</span> : atan(_Tp __x)</span>
<span id="L140"><span class="lineNum"> 140</span> : { return __builtin_atan(__x); }</span>
<span id="L141"><span class="lineNum"> 141</span> : </span>
<span id="L142"><span class="lineNum"> 142</span> : using ::atan2;</span>
<span id="L143"><span class="lineNum"> 143</span> : </span>
<span id="L144"><span class="lineNum"> 144</span> : #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO</span>
<span id="L145"><span class="lineNum"> 145</span> : inline _GLIBCXX_CONSTEXPR float</span>
<span id="L146"><span class="lineNum"> 146</span> : atan2(float __y, float __x)</span>
<span id="L147"><span class="lineNum"> 147</span> : { return __builtin_atan2f(__y, __x); }</span>
<span id="L148"><span class="lineNum"> 148</span> : </span>
<span id="L149"><span class="lineNum"> 149</span> : inline _GLIBCXX_CONSTEXPR long double</span>
<span id="L150"><span class="lineNum"> 150</span> : atan2(long double __y, long double __x)</span>
<span id="L151"><span class="lineNum"> 151</span> : { return __builtin_atan2l(__y, __x); }</span>
<span id="L152"><span class="lineNum"> 152</span> : #endif</span>
<span id="L153"><span class="lineNum"> 153</span> : </span>
<span id="L154"><span class="lineNum"> 154</span> : using ::ceil;</span>
<span id="L155"><span class="lineNum"> 155</span> : </span>
<span id="L156"><span class="lineNum"> 156</span> : #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO</span>
<span id="L157"><span class="lineNum"> 157</span> : inline _GLIBCXX_CONSTEXPR float</span>
<span id="L158"><span class="lineNum"> 158</span> : ceil(float __x)</span>
<span id="L159"><span class="lineNum"> 159</span> : { return __builtin_ceilf(__x); }</span>
<span id="L160"><span class="lineNum"> 160</span> : </span>
<span id="L161"><span class="lineNum"> 161</span> : inline _GLIBCXX_CONSTEXPR long double</span>
<span id="L162"><span class="lineNum"> 162</span> : ceil(long double __x)</span>
<span id="L163"><span class="lineNum"> 163</span> : { return __builtin_ceill(__x); }</span>
<span id="L164"><span class="lineNum"> 164</span> : #endif</span>
<span id="L165"><span class="lineNum"> 165</span> : </span>
<span id="L166"><span class="lineNum"> 166</span> : template&lt;typename _Tp&gt;</span>
<span id="L167"><span class="lineNum"> 167</span> : inline _GLIBCXX_CONSTEXPR</span>
<span id="L168"><span class="lineNum"> 168</span> : typename __gnu_cxx::__enable_if&lt;__is_integer&lt;_Tp&gt;::__value, </span>
<span id="L169"><span class="lineNum"> 169</span> : double&gt;::__type</span>
<span id="L170"><span class="lineNum"> 170</span> : ceil(_Tp __x)</span>
<span id="L171"><span class="lineNum"> 171</span> : { return __builtin_ceil(__x); }</span>
<span id="L172"><span class="lineNum"> 172</span> : </span>
<span id="L173"><span class="lineNum"> 173</span> : using ::cos;</span>
<span id="L174"><span class="lineNum"> 174</span> : </span>
<span id="L175"><span class="lineNum"> 175</span> : #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO</span>
<span id="L176"><span class="lineNum"> 176</span> : inline _GLIBCXX_CONSTEXPR float</span>
<span id="L177"><span class="lineNum"> 177</span> : cos(float __x)</span>
<span id="L178"><span class="lineNum"> 178</span> : { return __builtin_cosf(__x); }</span>
<span id="L179"><span class="lineNum"> 179</span> : </span>
<span id="L180"><span class="lineNum"> 180</span> : inline _GLIBCXX_CONSTEXPR long double</span>
<span id="L181"><span class="lineNum"> 181</span> : cos(long double __x)</span>
<span id="L182"><span class="lineNum"> 182</span> : { return __builtin_cosl(__x); }</span>
<span id="L183"><span class="lineNum"> 183</span> : #endif</span>
<span id="L184"><span class="lineNum"> 184</span> : </span>
<span id="L185"><span class="lineNum"> 185</span> : template&lt;typename _Tp&gt;</span>
<span id="L186"><span class="lineNum"> 186</span> : inline _GLIBCXX_CONSTEXPR</span>
<span id="L187"><span class="lineNum"> 187</span> : typename __gnu_cxx::__enable_if&lt;__is_integer&lt;_Tp&gt;::__value,</span>
<span id="L188"><span class="lineNum"> 188</span> : double&gt;::__type</span>
<span id="L189"><span class="lineNum"> 189</span> : cos(_Tp __x)</span>
<span id="L190"><span class="lineNum"> 190</span> : { return __builtin_cos(__x); }</span>
<span id="L191"><span class="lineNum"> 191</span> : </span>
<span id="L192"><span class="lineNum"> 192</span> : using ::cosh;</span>
<span id="L193"><span class="lineNum"> 193</span> : </span>
<span id="L194"><span class="lineNum"> 194</span> : #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO</span>
<span id="L195"><span class="lineNum"> 195</span> : inline _GLIBCXX_CONSTEXPR float</span>
<span id="L196"><span class="lineNum"> 196</span> : cosh(float __x)</span>
<span id="L197"><span class="lineNum"> 197</span> : { return __builtin_coshf(__x); }</span>
<span id="L198"><span class="lineNum"> 198</span> : </span>
<span id="L199"><span class="lineNum"> 199</span> : inline _GLIBCXX_CONSTEXPR long double</span>
<span id="L200"><span class="lineNum"> 200</span> : cosh(long double __x)</span>
<span id="L201"><span class="lineNum"> 201</span> : { return __builtin_coshl(__x); }</span>
<span id="L202"><span class="lineNum"> 202</span> : #endif</span>
<span id="L203"><span class="lineNum"> 203</span> : </span>
<span id="L204"><span class="lineNum"> 204</span> : template&lt;typename _Tp&gt;</span>
<span id="L205"><span class="lineNum"> 205</span> : inline _GLIBCXX_CONSTEXPR</span>
<span id="L206"><span class="lineNum"> 206</span> : typename __gnu_cxx::__enable_if&lt;__is_integer&lt;_Tp&gt;::__value,</span>
<span id="L207"><span class="lineNum"> 207</span> : double&gt;::__type</span>
<span id="L208"><span class="lineNum"> 208</span> : cosh(_Tp __x)</span>
<span id="L209"><span class="lineNum"> 209</span> : { return __builtin_cosh(__x); }</span>
<span id="L210"><span class="lineNum"> 210</span> : </span>
<span id="L211"><span class="lineNum"> 211</span> : using ::exp;</span>
<span id="L212"><span class="lineNum"> 212</span> : </span>
<span id="L213"><span class="lineNum"> 213</span> : #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO</span>
<span id="L214"><span class="lineNum"> 214</span> : inline _GLIBCXX_CONSTEXPR float</span>
<span id="L215"><span class="lineNum"> 215</span> : exp(float __x)</span>
<span id="L216"><span class="lineNum"> 216</span> : { return __builtin_expf(__x); }</span>
<span id="L217"><span class="lineNum"> 217</span> : </span>
<span id="L218"><span class="lineNum"> 218</span> : inline _GLIBCXX_CONSTEXPR long double</span>
<span id="L219"><span class="lineNum"> 219</span> : exp(long double __x)</span>
<span id="L220"><span class="lineNum"> 220</span> : { return __builtin_expl(__x); }</span>
<span id="L221"><span class="lineNum"> 221</span> : #endif</span>
<span id="L222"><span class="lineNum"> 222</span> : </span>
<span id="L223"><span class="lineNum"> 223</span> : template&lt;typename _Tp&gt;</span>
<span id="L224"><span class="lineNum"> 224</span> : inline _GLIBCXX_CONSTEXPR</span>
<span id="L225"><span class="lineNum"> 225</span> : typename __gnu_cxx::__enable_if&lt;__is_integer&lt;_Tp&gt;::__value,</span>
<span id="L226"><span class="lineNum"> 226</span> : double&gt;::__type</span>
<span id="L227"><span class="lineNum"> 227</span> : exp(_Tp __x)</span>
<span id="L228"><span class="lineNum"> 228</span> : { return __builtin_exp(__x); }</span>
<span id="L229"><span class="lineNum"> 229</span> : </span>
<span id="L230"><span class="lineNum"> 230</span> : using ::fabs;</span>
<span id="L231"><span class="lineNum"> 231</span> : </span>
<span id="L232"><span class="lineNum"> 232</span> : #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO</span>
<span id="L233"><span class="lineNum"> 233</span> : inline _GLIBCXX_CONSTEXPR float</span>
<span id="L234"><span class="lineNum"> 234</span> : fabs(float __x)</span>
<span id="L235"><span class="lineNum"> 235</span> : { return __builtin_fabsf(__x); }</span>
<span id="L236"><span class="lineNum"> 236</span> : </span>
<span id="L237"><span class="lineNum"> 237</span> : inline _GLIBCXX_CONSTEXPR long double</span>
<span id="L238"><span class="lineNum"> 238</span> : fabs(long double __x)</span>
<span id="L239"><span class="lineNum"> 239</span> : { return __builtin_fabsl(__x); }</span>
<span id="L240"><span class="lineNum"> 240</span> : #endif</span>
<span id="L241"><span class="lineNum"> 241</span> : </span>
<span id="L242"><span class="lineNum"> 242</span> : template&lt;typename _Tp&gt;</span>
<span id="L243"><span class="lineNum"> 243</span> : inline _GLIBCXX_CONSTEXPR</span>
<span id="L244"><span class="lineNum"> 244</span> : typename __gnu_cxx::__enable_if&lt;__is_integer&lt;_Tp&gt;::__value,</span>
<span id="L245"><span class="lineNum"> 245</span> : double&gt;::__type</span>
<span id="L246"><span class="lineNum"> 246</span> : fabs(_Tp __x)</span>
<span id="L247"><span class="lineNum"> 247</span> : { return __builtin_fabs(__x); }</span>
<span id="L248"><span class="lineNum"> 248</span> : </span>
<span id="L249"><span class="lineNum"> 249</span> : using ::floor;</span>
<span id="L250"><span class="lineNum"> 250</span> : </span>
<span id="L251"><span class="lineNum"> 251</span> : #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO</span>
<span id="L252"><span class="lineNum"> 252</span> : inline _GLIBCXX_CONSTEXPR float</span>
<span id="L253"><span class="lineNum"> 253</span> : floor(float __x)</span>
<span id="L254"><span class="lineNum"> 254</span> : { return __builtin_floorf(__x); }</span>
<span id="L255"><span class="lineNum"> 255</span> : </span>
<span id="L256"><span class="lineNum"> 256</span> : inline _GLIBCXX_CONSTEXPR long double</span>
<span id="L257"><span class="lineNum"> 257</span> : floor(long double __x)</span>
<span id="L258"><span class="lineNum"> 258</span> : { return __builtin_floorl(__x); }</span>
<span id="L259"><span class="lineNum"> 259</span> : #endif</span>
<span id="L260"><span class="lineNum"> 260</span> : </span>
<span id="L261"><span class="lineNum"> 261</span> : template&lt;typename _Tp&gt;</span>
<span id="L262"><span class="lineNum"> 262</span> : inline _GLIBCXX_CONSTEXPR</span>
<span id="L263"><span class="lineNum"> 263</span> : typename __gnu_cxx::__enable_if&lt;__is_integer&lt;_Tp&gt;::__value,</span>
<span id="L264"><span class="lineNum"> 264</span> : double&gt;::__type</span>
<span id="L265"><span class="lineNum"> 265</span> : floor(_Tp __x)</span>
<span id="L266"><span class="lineNum"> 266</span> : { return __builtin_floor(__x); }</span>
<span id="L267"><span class="lineNum"> 267</span> : </span>
<span id="L268"><span class="lineNum"> 268</span> : using ::fmod;</span>
<span id="L269"><span class="lineNum"> 269</span> : </span>
<span id="L270"><span class="lineNum"> 270</span> : #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO</span>
<span id="L271"><span class="lineNum"> 271</span> : inline _GLIBCXX_CONSTEXPR float</span>
<span id="L272"><span class="lineNum"> 272</span> : fmod(float __x, float __y)</span>
<span id="L273"><span class="lineNum"> 273</span> : { return __builtin_fmodf(__x, __y); }</span>
<span id="L274"><span class="lineNum"> 274</span> : </span>
<span id="L275"><span class="lineNum"> 275</span> : inline _GLIBCXX_CONSTEXPR long double</span>
<span id="L276"><span class="lineNum"> 276</span> : fmod(long double __x, long double __y)</span>
<span id="L277"><span class="lineNum"> 277</span> : { return __builtin_fmodl(__x, __y); }</span>
<span id="L278"><span class="lineNum"> 278</span> : #endif</span>
<span id="L279"><span class="lineNum"> 279</span> : </span>
<span id="L280"><span class="lineNum"> 280</span> : using ::frexp;</span>
<span id="L281"><span class="lineNum"> 281</span> : </span>
<span id="L282"><span class="lineNum"> 282</span> : #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO</span>
<span id="L283"><span class="lineNum"> 283</span> : inline float</span>
<span id="L284"><span class="lineNum"> 284</span> : frexp(float __x, int* __exp)</span>
<span id="L285"><span class="lineNum"> 285</span> : { return __builtin_frexpf(__x, __exp); }</span>
<span id="L286"><span class="lineNum"> 286</span> : </span>
<span id="L287"><span class="lineNum"> 287</span> : inline long double</span>
<span id="L288"><span class="lineNum"> 288</span> : frexp(long double __x, int* __exp)</span>
<span id="L289"><span class="lineNum"> 289</span> : { return __builtin_frexpl(__x, __exp); }</span>
<span id="L290"><span class="lineNum"> 290</span> : #endif</span>
<span id="L291"><span class="lineNum"> 291</span> : </span>
<span id="L292"><span class="lineNum"> 292</span> : template&lt;typename _Tp&gt;</span>
<span id="L293"><span class="lineNum"> 293</span> : inline _GLIBCXX_CONSTEXPR</span>
<span id="L294"><span class="lineNum"> 294</span> : typename __gnu_cxx::__enable_if&lt;__is_integer&lt;_Tp&gt;::__value, </span>
<span id="L295"><span class="lineNum"> 295</span> : double&gt;::__type</span>
<span id="L296"><span class="lineNum"> 296</span> : frexp(_Tp __x, int* __exp)</span>
<span id="L297"><span class="lineNum"> 297</span> : { return __builtin_frexp(__x, __exp); }</span>
<span id="L298"><span class="lineNum"> 298</span> : </span>
<span id="L299"><span class="lineNum"> 299</span> : using ::ldexp;</span>
<span id="L300"><span class="lineNum"> 300</span> : </span>
<span id="L301"><span class="lineNum"> 301</span> : #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO</span>
<span id="L302"><span class="lineNum"> 302</span> : inline _GLIBCXX_CONSTEXPR float</span>
<span id="L303"><span class="lineNum"> 303</span> : ldexp(float __x, int __exp)</span>
<span id="L304"><span class="lineNum"> 304</span> : { return __builtin_ldexpf(__x, __exp); }</span>
<span id="L305"><span class="lineNum"> 305</span> : </span>
<span id="L306"><span class="lineNum"> 306</span> : inline _GLIBCXX_CONSTEXPR long double</span>
<span id="L307"><span class="lineNum"> 307</span> : ldexp(long double __x, int __exp)</span>
<span id="L308"><span class="lineNum"> 308</span> : { return __builtin_ldexpl(__x, __exp); }</span>
<span id="L309"><span class="lineNum"> 309</span> : #endif</span>
<span id="L310"><span class="lineNum"> 310</span> : </span>
<span id="L311"><span class="lineNum"> 311</span> : template&lt;typename _Tp&gt;</span>
<span id="L312"><span class="lineNum"> 312</span> : inline _GLIBCXX_CONSTEXPR</span>
<span id="L313"><span class="lineNum"> 313</span> : typename __gnu_cxx::__enable_if&lt;__is_integer&lt;_Tp&gt;::__value, </span>
<span id="L314"><span class="lineNum"> 314</span> : double&gt;::__type</span>
<span id="L315"><span class="lineNum"> 315</span> : ldexp(_Tp __x, int __exp)</span>
<span id="L316"><span class="lineNum"> 316</span> : { return __builtin_ldexp(__x, __exp); }</span>
<span id="L317"><span class="lineNum"> 317</span> : </span>
<span id="L318"><span class="lineNum"> 318</span> : using ::log;</span>
<span id="L319"><span class="lineNum"> 319</span> : </span>
<span id="L320"><span class="lineNum"> 320</span> : #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO</span>
<span id="L321"><span class="lineNum"> 321</span> : inline _GLIBCXX_CONSTEXPR float</span>
<span id="L322"><span class="lineNum"> 322</span> : log(float __x)</span>
<span id="L323"><span class="lineNum"> 323</span> : { return __builtin_logf(__x); }</span>
<span id="L324"><span class="lineNum"> 324</span> : </span>
<span id="L325"><span class="lineNum"> 325</span> : inline _GLIBCXX_CONSTEXPR long double</span>
<span id="L326"><span class="lineNum"> 326</span> : log(long double __x)</span>
<span id="L327"><span class="lineNum"> 327</span> : { return __builtin_logl(__x); }</span>
<span id="L328"><span class="lineNum"> 328</span> : #endif</span>
<span id="L329"><span class="lineNum"> 329</span> : </span>
<span id="L330"><span class="lineNum"> 330</span> : template&lt;typename _Tp&gt;</span>
<span id="L331"><span class="lineNum"> 331</span> : inline _GLIBCXX_CONSTEXPR</span>
<span id="L332"><span class="lineNum"> 332</span> : typename __gnu_cxx::__enable_if&lt;__is_integer&lt;_Tp&gt;::__value, </span>
<span id="L333"><span class="lineNum"> 333</span> : double&gt;::__type</span>
<span id="L334"><span class="lineNum"> 334</span> : log(_Tp __x)</span>
<span id="L335"><span class="lineNum"> 335</span> : { return __builtin_log(__x); }</span>
<span id="L336"><span class="lineNum"> 336</span> : </span>
<span id="L337"><span class="lineNum"> 337</span> : using ::log10;</span>
<span id="L338"><span class="lineNum"> 338</span> : </span>
<span id="L339"><span class="lineNum"> 339</span> : #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO</span>
<span id="L340"><span class="lineNum"> 340</span> : inline _GLIBCXX_CONSTEXPR float</span>
<span id="L341"><span class="lineNum"> 341</span> : log10(float __x)</span>
<span id="L342"><span class="lineNum"> 342</span> : { return __builtin_log10f(__x); }</span>
<span id="L343"><span class="lineNum"> 343</span> : </span>
<span id="L344"><span class="lineNum"> 344</span> : inline _GLIBCXX_CONSTEXPR long double</span>
<span id="L345"><span class="lineNum"> 345</span> : log10(long double __x)</span>
<span id="L346"><span class="lineNum"> 346</span> : { return __builtin_log10l(__x); }</span>
<span id="L347"><span class="lineNum"> 347</span> : #endif</span>
<span id="L348"><span class="lineNum"> 348</span> : </span>
<span id="L349"><span class="lineNum"> 349</span> : template&lt;typename _Tp&gt;</span>
<span id="L350"><span class="lineNum"> 350</span> : inline _GLIBCXX_CONSTEXPR</span>
<span id="L351"><span class="lineNum"> 351</span> : typename __gnu_cxx::__enable_if&lt;__is_integer&lt;_Tp&gt;::__value,</span>
<span id="L352"><span class="lineNum"> 352</span> : double&gt;::__type</span>
<span id="L353"><span class="lineNum"> 353</span> : log10(_Tp __x)</span>
<span id="L354"><span class="lineNum"> 354</span> : { return __builtin_log10(__x); }</span>
<span id="L355"><span class="lineNum"> 355</span> : </span>
<span id="L356"><span class="lineNum"> 356</span> : using ::modf;</span>
<span id="L357"><span class="lineNum"> 357</span> : </span>
<span id="L358"><span class="lineNum"> 358</span> : #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO</span>
<span id="L359"><span class="lineNum"> 359</span> : inline float</span>
<span id="L360"><span class="lineNum"> 360</span> : modf(float __x, float* __iptr)</span>
<span id="L361"><span class="lineNum"> 361</span> : { return __builtin_modff(__x, __iptr); }</span>
<span id="L362"><span class="lineNum"> 362</span> : </span>
<span id="L363"><span class="lineNum"> 363</span> : inline long double</span>
<span id="L364"><span class="lineNum"> 364</span> : modf(long double __x, long double* __iptr)</span>
<span id="L365"><span class="lineNum"> 365</span> : { return __builtin_modfl(__x, __iptr); }</span>
<span id="L366"><span class="lineNum"> 366</span> : #endif</span>
<span id="L367"><span class="lineNum"> 367</span> : </span>
<span id="L368"><span class="lineNum"> 368</span> : using ::pow;</span>
<span id="L369"><span class="lineNum"> 369</span> : </span>
<span id="L370"><span class="lineNum"> 370</span> : #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO</span>
<span id="L371"><span class="lineNum"> 371</span> : inline _GLIBCXX_CONSTEXPR float</span>
<span id="L372"><span class="lineNum"> 372</span> : pow(float __x, float __y)</span>
<span id="L373"><span class="lineNum"> 373</span> : { return __builtin_powf(__x, __y); }</span>
<span id="L374"><span class="lineNum"> 374</span> : </span>
<span id="L375"><span class="lineNum"> 375</span> : inline _GLIBCXX_CONSTEXPR long double</span>
<span id="L376"><span class="lineNum"> 376</span> : pow(long double __x, long double __y)</span>
<span id="L377"><span class="lineNum"> 377</span> : { return __builtin_powl(__x, __y); }</span>
<span id="L378"><span class="lineNum"> 378</span> : </span>
<span id="L379"><span class="lineNum"> 379</span> : #if __cplusplus &lt; 201103L</span>
<span id="L380"><span class="lineNum"> 380</span> : // _GLIBCXX_RESOLVE_LIB_DEFECTS</span>
<span id="L381"><span class="lineNum"> 381</span> : // DR 550. What should the return type of pow(float,int) be?</span>
<span id="L382"><span class="lineNum"> 382</span> : inline double</span>
<span id="L383"><span class="lineNum"> 383</span> : pow(double __x, int __i)</span>
<span id="L384"><span class="lineNum"> 384</span> : { return __builtin_powi(__x, __i); }</span>
<span id="L385"><span class="lineNum"> 385</span> : </span>
<span id="L386"><span class="lineNum"> 386</span> : inline float</span>
<span id="L387"><span class="lineNum"> 387</span> : pow(float __x, int __n)</span>
<span id="L388"><span class="lineNum"> 388</span> : { return __builtin_powif(__x, __n); }</span>
<span id="L389"><span class="lineNum"> 389</span> : </span>
<span id="L390"><span class="lineNum"> 390</span> : inline long double</span>
<span id="L391"><span class="lineNum"> 391</span> : pow(long double __x, int __n)</span>
<span id="L392"><span class="lineNum"> 392</span> : { return __builtin_powil(__x, __n); }</span>
<span id="L393"><span class="lineNum"> 393</span> : #endif</span>
<span id="L394"><span class="lineNum"> 394</span> : #endif</span>
<span id="L395"><span class="lineNum"> 395</span> : </span>
<span id="L396"><span class="lineNum"> 396</span> : using ::sin;</span>
<span id="L397"><span class="lineNum"> 397</span> : </span>
<span id="L398"><span class="lineNum"> 398</span> : #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO</span>
<span id="L399"><span class="lineNum"> 399</span> : inline _GLIBCXX_CONSTEXPR float</span>
<span id="L400"><span class="lineNum"> 400</span> : sin(float __x)</span>
<span id="L401"><span class="lineNum"> 401</span> : { return __builtin_sinf(__x); }</span>
<span id="L402"><span class="lineNum"> 402</span> : </span>
<span id="L403"><span class="lineNum"> 403</span> : inline _GLIBCXX_CONSTEXPR long double</span>
<span id="L404"><span class="lineNum"> 404</span> : sin(long double __x)</span>
<span id="L405"><span class="lineNum"> 405</span> : { return __builtin_sinl(__x); }</span>
<span id="L406"><span class="lineNum"> 406</span> : #endif</span>
<span id="L407"><span class="lineNum"> 407</span> : </span>
<span id="L408"><span class="lineNum"> 408</span> : template&lt;typename _Tp&gt;</span>
<span id="L409"><span class="lineNum"> 409</span> : inline _GLIBCXX_CONSTEXPR</span>
<span id="L410"><span class="lineNum"> 410</span> : typename __gnu_cxx::__enable_if&lt;__is_integer&lt;_Tp&gt;::__value, </span>
<span id="L411"><span class="lineNum"> 411</span> : double&gt;::__type</span>
<span id="L412"><span class="lineNum"> 412</span> : sin(_Tp __x)</span>
<span id="L413"><span class="lineNum"> 413</span> : { return __builtin_sin(__x); }</span>
<span id="L414"><span class="lineNum"> 414</span> : </span>
<span id="L415"><span class="lineNum"> 415</span> : using ::sinh;</span>
<span id="L416"><span class="lineNum"> 416</span> : </span>
<span id="L417"><span class="lineNum"> 417</span> : #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO</span>
<span id="L418"><span class="lineNum"> 418</span> : inline _GLIBCXX_CONSTEXPR float</span>
<span id="L419"><span class="lineNum"> 419</span> : sinh(float __x)</span>
<span id="L420"><span class="lineNum"> 420</span> : { return __builtin_sinhf(__x); }</span>
<span id="L421"><span class="lineNum"> 421</span> : </span>
<span id="L422"><span class="lineNum"> 422</span> : inline _GLIBCXX_CONSTEXPR long double</span>
<span id="L423"><span class="lineNum"> 423</span> : sinh(long double __x)</span>
<span id="L424"><span class="lineNum"> 424</span> : { return __builtin_sinhl(__x); }</span>
<span id="L425"><span class="lineNum"> 425</span> : #endif</span>
<span id="L426"><span class="lineNum"> 426</span> : </span>
<span id="L427"><span class="lineNum"> 427</span> : template&lt;typename _Tp&gt;</span>
<span id="L428"><span class="lineNum"> 428</span> : inline _GLIBCXX_CONSTEXPR</span>
<span id="L429"><span class="lineNum"> 429</span> : typename __gnu_cxx::__enable_if&lt;__is_integer&lt;_Tp&gt;::__value, </span>
<span id="L430"><span class="lineNum"> 430</span> : double&gt;::__type</span>
<span id="L431"><span class="lineNum"> 431</span> : sinh(_Tp __x)</span>
<span id="L432"><span class="lineNum"> 432</span> : { return __builtin_sinh(__x); }</span>
<span id="L433"><span class="lineNum"> 433</span> : </span>
<span id="L434"><span class="lineNum"> 434</span> : using ::sqrt;</span>
<span id="L435"><span class="lineNum"> 435</span> : </span>
<span id="L436"><span class="lineNum"> 436</span> : #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO</span>
<span id="L437"><span class="lineNum"> 437</span> : inline _GLIBCXX_CONSTEXPR float</span>
<span id="L438"><span class="lineNum"> 438</span> : sqrt(float __x)</span>
<span id="L439"><span class="lineNum"> 439</span> : { return __builtin_sqrtf(__x); }</span>
<span id="L440"><span class="lineNum"> 440</span> : </span>
<span id="L441"><span class="lineNum"> 441</span> : inline _GLIBCXX_CONSTEXPR long double</span>
<span id="L442"><span class="lineNum"> 442</span> : sqrt(long double __x)</span>
<span id="L443"><span class="lineNum"> 443</span> : { return __builtin_sqrtl(__x); }</span>
<span id="L444"><span class="lineNum"> 444</span> : #endif</span>
<span id="L445"><span class="lineNum"> 445</span> : </span>
<span id="L446"><span class="lineNum"> 446</span> : template&lt;typename _Tp&gt;</span>
<span id="L447"><span class="lineNum"> 447</span> : inline _GLIBCXX_CONSTEXPR</span>
<span id="L448"><span class="lineNum"> 448</span> : typename __gnu_cxx::__enable_if&lt;__is_integer&lt;_Tp&gt;::__value, </span>
<span id="L449"><span class="lineNum"> 449</span> : double&gt;::__type</span>
<span id="L450"><span class="lineNum"> 450</span> : sqrt(_Tp __x)</span>
<span id="L451"><span class="lineNum"> 451</span> : { return __builtin_sqrt(__x); }</span>
<span id="L452"><span class="lineNum"> 452</span> : </span>
<span id="L453"><span class="lineNum"> 453</span> : using ::tan;</span>
<span id="L454"><span class="lineNum"> 454</span> : </span>
<span id="L455"><span class="lineNum"> 455</span> : #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO</span>
<span id="L456"><span class="lineNum"> 456</span> : inline _GLIBCXX_CONSTEXPR float</span>
<span id="L457"><span class="lineNum"> 457</span> : tan(float __x)</span>
<span id="L458"><span class="lineNum"> 458</span> : { return __builtin_tanf(__x); }</span>
<span id="L459"><span class="lineNum"> 459</span> : </span>
<span id="L460"><span class="lineNum"> 460</span> : inline _GLIBCXX_CONSTEXPR long double</span>
<span id="L461"><span class="lineNum"> 461</span> : tan(long double __x)</span>
<span id="L462"><span class="lineNum"> 462</span> : { return __builtin_tanl(__x); }</span>
<span id="L463"><span class="lineNum"> 463</span> : #endif</span>
<span id="L464"><span class="lineNum"> 464</span> : </span>
<span id="L465"><span class="lineNum"> 465</span> : template&lt;typename _Tp&gt;</span>
<span id="L466"><span class="lineNum"> 466</span> : inline _GLIBCXX_CONSTEXPR</span>
<span id="L467"><span class="lineNum"> 467</span> : typename __gnu_cxx::__enable_if&lt;__is_integer&lt;_Tp&gt;::__value, </span>
<span id="L468"><span class="lineNum"> 468</span> : double&gt;::__type</span>
<span id="L469"><span class="lineNum"> 469</span> : tan(_Tp __x)</span>
<span id="L470"><span class="lineNum"> 470</span> : { return __builtin_tan(__x); }</span>
<span id="L471"><span class="lineNum"> 471</span> : </span>
<span id="L472"><span class="lineNum"> 472</span> : using ::tanh;</span>
<span id="L473"><span class="lineNum"> 473</span> : </span>
<span id="L474"><span class="lineNum"> 474</span> : #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO</span>
<span id="L475"><span class="lineNum"> 475</span> : inline _GLIBCXX_CONSTEXPR float</span>
<span id="L476"><span class="lineNum"> 476</span> : tanh(float __x)</span>
<span id="L477"><span class="lineNum"> 477</span> : { return __builtin_tanhf(__x); }</span>
<span id="L478"><span class="lineNum"> 478</span> : </span>
<span id="L479"><span class="lineNum"> 479</span> : inline _GLIBCXX_CONSTEXPR long double</span>
<span id="L480"><span class="lineNum"> 480</span> : tanh(long double __x)</span>
<span id="L481"><span class="lineNum"> 481</span> : { return __builtin_tanhl(__x); }</span>
<span id="L482"><span class="lineNum"> 482</span> : #endif</span>
<span id="L483"><span class="lineNum"> 483</span> : </span>
<span id="L484"><span class="lineNum"> 484</span> : template&lt;typename _Tp&gt;</span>
<span id="L485"><span class="lineNum"> 485</span> : inline _GLIBCXX_CONSTEXPR</span>
<span id="L486"><span class="lineNum"> 486</span> : typename __gnu_cxx::__enable_if&lt;__is_integer&lt;_Tp&gt;::__value, </span>
<span id="L487"><span class="lineNum"> 487</span> : double&gt;::__type</span>
<span id="L488"><span class="lineNum"> 488</span> : tanh(_Tp __x)</span>
<span id="L489"><span class="lineNum"> 489</span> : { return __builtin_tanh(__x); }</span>
<span id="L490"><span class="lineNum"> 490</span> : </span>
<span id="L491"><span class="lineNum"> 491</span> : #if defined(__STDCPP_FLOAT16_T__) &amp;&amp; defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)</span>
<span id="L492"><span class="lineNum"> 492</span> : constexpr _Float16</span>
<span id="L493"><span class="lineNum"> 493</span> : acos(_Float16 __x)</span>
<span id="L494"><span class="lineNum"> 494</span> : { return _Float16(__builtin_acosf(__x)); }</span>
<span id="L495"><span class="lineNum"> 495</span> : </span>
<span id="L496"><span class="lineNum"> 496</span> : constexpr _Float16</span>
<span id="L497"><span class="lineNum"> 497</span> : asin(_Float16 __x)</span>
<span id="L498"><span class="lineNum"> 498</span> : { return _Float16(__builtin_asinf(__x)); }</span>
<span id="L499"><span class="lineNum"> 499</span> : </span>
<span id="L500"><span class="lineNum"> 500</span> : constexpr _Float16</span>
<span id="L501"><span class="lineNum"> 501</span> : atan(_Float16 __x)</span>
<span id="L502"><span class="lineNum"> 502</span> : { return _Float16(__builtin_atanf(__x)); }</span>
<span id="L503"><span class="lineNum"> 503</span> : </span>
<span id="L504"><span class="lineNum"> 504</span> : constexpr _Float16</span>
<span id="L505"><span class="lineNum"> 505</span> : atan2(_Float16 __y, _Float16 __x)</span>
<span id="L506"><span class="lineNum"> 506</span> : { return _Float16(__builtin_atan2f(__y, __x)); }</span>
<span id="L507"><span class="lineNum"> 507</span> : </span>
<span id="L508"><span class="lineNum"> 508</span> : constexpr _Float16</span>
<span id="L509"><span class="lineNum"> 509</span> : ceil(_Float16 __x)</span>
<span id="L510"><span class="lineNum"> 510</span> : { return _Float16(__builtin_ceilf(__x)); }</span>
<span id="L511"><span class="lineNum"> 511</span> : </span>
<span id="L512"><span class="lineNum"> 512</span> : constexpr _Float16</span>
<span id="L513"><span class="lineNum"> 513</span> : cos(_Float16 __x)</span>
<span id="L514"><span class="lineNum"> 514</span> : { return _Float16(__builtin_cosf(__x)); }</span>
<span id="L515"><span class="lineNum"> 515</span> : </span>
<span id="L516"><span class="lineNum"> 516</span> : constexpr _Float16</span>
<span id="L517"><span class="lineNum"> 517</span> : cosh(_Float16 __x)</span>
<span id="L518"><span class="lineNum"> 518</span> : { return _Float16(__builtin_coshf(__x)); }</span>
<span id="L519"><span class="lineNum"> 519</span> : </span>
<span id="L520"><span class="lineNum"> 520</span> : constexpr _Float16</span>
<span id="L521"><span class="lineNum"> 521</span> : exp(_Float16 __x)</span>
<span id="L522"><span class="lineNum"> 522</span> : { return _Float16(__builtin_expf(__x)); }</span>
<span id="L523"><span class="lineNum"> 523</span> : </span>
<span id="L524"><span class="lineNum"> 524</span> : constexpr _Float16</span>
<span id="L525"><span class="lineNum"> 525</span> : fabs(_Float16 __x)</span>
<span id="L526"><span class="lineNum"> 526</span> : { return _Float16(__builtin_fabsf(__x)); }</span>
<span id="L527"><span class="lineNum"> 527</span> : </span>
<span id="L528"><span class="lineNum"> 528</span> : constexpr _Float16</span>
<span id="L529"><span class="lineNum"> 529</span> : floor(_Float16 __x)</span>
<span id="L530"><span class="lineNum"> 530</span> : { return _Float16(__builtin_floorf(__x)); }</span>
<span id="L531"><span class="lineNum"> 531</span> : </span>
<span id="L532"><span class="lineNum"> 532</span> : constexpr _Float16</span>
<span id="L533"><span class="lineNum"> 533</span> : fmod(_Float16 __x, _Float16 __y)</span>
<span id="L534"><span class="lineNum"> 534</span> : { return _Float16(__builtin_fmodf(__x, __y)); }</span>
<span id="L535"><span class="lineNum"> 535</span> : </span>
<span id="L536"><span class="lineNum"> 536</span> : inline _Float16</span>
<span id="L537"><span class="lineNum"> 537</span> : frexp(_Float16 __x, int* __exp)</span>
<span id="L538"><span class="lineNum"> 538</span> : { return _Float16(__builtin_frexpf(__x, __exp)); }</span>
<span id="L539"><span class="lineNum"> 539</span> : </span>
<span id="L540"><span class="lineNum"> 540</span> : constexpr _Float16</span>
<span id="L541"><span class="lineNum"> 541</span> : ldexp(_Float16 __x, int __exp)</span>
<span id="L542"><span class="lineNum"> 542</span> : { return _Float16(__builtin_ldexpf(__x, __exp)); }</span>
<span id="L543"><span class="lineNum"> 543</span> : </span>
<span id="L544"><span class="lineNum"> 544</span> : constexpr _Float16</span>
<span id="L545"><span class="lineNum"> 545</span> : log(_Float16 __x)</span>
<span id="L546"><span class="lineNum"> 546</span> : { return _Float16(__builtin_logf(__x)); }</span>
<span id="L547"><span class="lineNum"> 547</span> : </span>
<span id="L548"><span class="lineNum"> 548</span> : constexpr _Float16</span>
<span id="L549"><span class="lineNum"> 549</span> : log10(_Float16 __x)</span>
<span id="L550"><span class="lineNum"> 550</span> : { return _Float16(__builtin_log10f(__x)); }</span>
<span id="L551"><span class="lineNum"> 551</span> : </span>
<span id="L552"><span class="lineNum"> 552</span> : inline _Float16</span>
<span id="L553"><span class="lineNum"> 553</span> : modf(_Float16 __x, _Float16* __iptr)</span>
<span id="L554"><span class="lineNum"> 554</span> : {</span>
<span id="L555"><span class="lineNum"> 555</span> : float __i, __ret = __builtin_modff(__x, &amp;__i);</span>
<span id="L556"><span class="lineNum"> 556</span> : *__iptr = _Float16(__i);</span>
<span id="L557"><span class="lineNum"> 557</span> : return _Float16(__ret);</span>
<span id="L558"><span class="lineNum"> 558</span> : }</span>
<span id="L559"><span class="lineNum"> 559</span> : </span>
<span id="L560"><span class="lineNum"> 560</span> : constexpr _Float16</span>
<span id="L561"><span class="lineNum"> 561</span> : pow(_Float16 __x, _Float16 __y)</span>
<span id="L562"><span class="lineNum"> 562</span> : { return _Float16(__builtin_powf(__x, __y)); }</span>
<span id="L563"><span class="lineNum"> 563</span> : </span>
<span id="L564"><span class="lineNum"> 564</span> : constexpr _Float16</span>
<span id="L565"><span class="lineNum"> 565</span> : sin(_Float16 __x)</span>
<span id="L566"><span class="lineNum"> 566</span> : { return _Float16(__builtin_sinf(__x)); }</span>
<span id="L567"><span class="lineNum"> 567</span> : </span>
<span id="L568"><span class="lineNum"> 568</span> : constexpr _Float16</span>
<span id="L569"><span class="lineNum"> 569</span> : sinh(_Float16 __x)</span>
<span id="L570"><span class="lineNum"> 570</span> : { return _Float16(__builtin_sinhf(__x)); }</span>
<span id="L571"><span class="lineNum"> 571</span> : </span>
<span id="L572"><span class="lineNum"> 572</span> : constexpr _Float16</span>
<span id="L573"><span class="lineNum"> 573</span> : sqrt(_Float16 __x)</span>
<span id="L574"><span class="lineNum"> 574</span> : { return _Float16(__builtin_sqrtf(__x)); }</span>
<span id="L575"><span class="lineNum"> 575</span> : </span>
<span id="L576"><span class="lineNum"> 576</span> : constexpr _Float16</span>
<span id="L577"><span class="lineNum"> 577</span> : tan(_Float16 __x)</span>
<span id="L578"><span class="lineNum"> 578</span> : { return _Float16(__builtin_tanf(__x)); }</span>
<span id="L579"><span class="lineNum"> 579</span> : </span>
<span id="L580"><span class="lineNum"> 580</span> : constexpr _Float16</span>
<span id="L581"><span class="lineNum"> 581</span> : tanh(_Float16 __x)</span>
<span id="L582"><span class="lineNum"> 582</span> : { return _Float16(__builtin_tanhf(__x)); }</span>
<span id="L583"><span class="lineNum"> 583</span> : #endif</span>
<span id="L584"><span class="lineNum"> 584</span> : </span>
<span id="L585"><span class="lineNum"> 585</span> : #if defined(__STDCPP_FLOAT32_T__) &amp;&amp; defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)</span>
<span id="L586"><span class="lineNum"> 586</span> : constexpr _Float32</span>
<span id="L587"><span class="lineNum"> 587</span> : acos(_Float32 __x)</span>
<span id="L588"><span class="lineNum"> 588</span> : { return __builtin_acosf(__x); }</span>
<span id="L589"><span class="lineNum"> 589</span> : </span>
<span id="L590"><span class="lineNum"> 590</span> : constexpr _Float32</span>
<span id="L591"><span class="lineNum"> 591</span> : asin(_Float32 __x)</span>
<span id="L592"><span class="lineNum"> 592</span> : { return __builtin_asinf(__x); }</span>
<span id="L593"><span class="lineNum"> 593</span> : </span>
<span id="L594"><span class="lineNum"> 594</span> : constexpr _Float32</span>
<span id="L595"><span class="lineNum"> 595</span> : atan(_Float32 __x)</span>
<span id="L596"><span class="lineNum"> 596</span> : { return __builtin_atanf(__x); }</span>
<span id="L597"><span class="lineNum"> 597</span> : </span>
<span id="L598"><span class="lineNum"> 598</span> : constexpr _Float32</span>
<span id="L599"><span class="lineNum"> 599</span> : atan2(_Float32 __y, _Float32 __x)</span>
<span id="L600"><span class="lineNum"> 600</span> : { return __builtin_atan2f(__y, __x); }</span>
<span id="L601"><span class="lineNum"> 601</span> : </span>
<span id="L602"><span class="lineNum"> 602</span> : constexpr _Float32</span>
<span id="L603"><span class="lineNum"> 603</span> : ceil(_Float32 __x)</span>
<span id="L604"><span class="lineNum"> 604</span> : { return __builtin_ceilf(__x); }</span>
<span id="L605"><span class="lineNum"> 605</span> : </span>
<span id="L606"><span class="lineNum"> 606</span> : constexpr _Float32</span>
<span id="L607"><span class="lineNum"> 607</span> : cos(_Float32 __x)</span>
<span id="L608"><span class="lineNum"> 608</span> : { return __builtin_cosf(__x); }</span>
<span id="L609"><span class="lineNum"> 609</span> : </span>
<span id="L610"><span class="lineNum"> 610</span> : constexpr _Float32</span>
<span id="L611"><span class="lineNum"> 611</span> : cosh(_Float32 __x)</span>
<span id="L612"><span class="lineNum"> 612</span> : { return __builtin_coshf(__x); }</span>
<span id="L613"><span class="lineNum"> 613</span> : </span>
<span id="L614"><span class="lineNum"> 614</span> : constexpr _Float32</span>
<span id="L615"><span class="lineNum"> 615</span> : exp(_Float32 __x)</span>
<span id="L616"><span class="lineNum"> 616</span> : { return __builtin_expf(__x); }</span>
<span id="L617"><span class="lineNum"> 617</span> : </span>
<span id="L618"><span class="lineNum"> 618</span> : constexpr _Float32</span>
<span id="L619"><span class="lineNum"> 619</span> : fabs(_Float32 __x)</span>
<span id="L620"><span class="lineNum"> 620</span> : { return __builtin_fabsf(__x); }</span>
<span id="L621"><span class="lineNum"> 621</span> : </span>
<span id="L622"><span class="lineNum"> 622</span> : constexpr _Float32</span>
<span id="L623"><span class="lineNum"> 623</span> : floor(_Float32 __x)</span>
<span id="L624"><span class="lineNum"> 624</span> : { return __builtin_floorf(__x); }</span>
<span id="L625"><span class="lineNum"> 625</span> : </span>
<span id="L626"><span class="lineNum"> 626</span> : constexpr _Float32</span>
<span id="L627"><span class="lineNum"> 627</span> : fmod(_Float32 __x, _Float32 __y)</span>
<span id="L628"><span class="lineNum"> 628</span> : { return __builtin_fmodf(__x, __y); }</span>
<span id="L629"><span class="lineNum"> 629</span> : </span>
<span id="L630"><span class="lineNum"> 630</span> : inline _Float32</span>
<span id="L631"><span class="lineNum"> 631</span> : frexp(_Float32 __x, int* __exp)</span>
<span id="L632"><span class="lineNum"> 632</span> : { return __builtin_frexpf(__x, __exp); }</span>
<span id="L633"><span class="lineNum"> 633</span> : </span>
<span id="L634"><span class="lineNum"> 634</span> : constexpr _Float32</span>
<span id="L635"><span class="lineNum"> 635</span> : ldexp(_Float32 __x, int __exp)</span>
<span id="L636"><span class="lineNum"> 636</span> : { return __builtin_ldexpf(__x, __exp); }</span>
<span id="L637"><span class="lineNum"> 637</span> : </span>
<span id="L638"><span class="lineNum"> 638</span> : constexpr _Float32</span>
<span id="L639"><span class="lineNum"> 639</span> : log(_Float32 __x)</span>
<span id="L640"><span class="lineNum"> 640</span> : { return __builtin_logf(__x); }</span>
<span id="L641"><span class="lineNum"> 641</span> : </span>
<span id="L642"><span class="lineNum"> 642</span> : constexpr _Float32</span>
<span id="L643"><span class="lineNum"> 643</span> : log10(_Float32 __x)</span>
<span id="L644"><span class="lineNum"> 644</span> : { return __builtin_log10f(__x); }</span>
<span id="L645"><span class="lineNum"> 645</span> : </span>
<span id="L646"><span class="lineNum"> 646</span> : inline _Float32</span>
<span id="L647"><span class="lineNum"> 647</span> : modf(_Float32 __x, _Float32* __iptr)</span>
<span id="L648"><span class="lineNum"> 648</span> : {</span>
<span id="L649"><span class="lineNum"> 649</span> : float __i, __ret = __builtin_modff(__x, &amp;__i);</span>
<span id="L650"><span class="lineNum"> 650</span> : *__iptr = __i;</span>
<span id="L651"><span class="lineNum"> 651</span> : return __ret;</span>
<span id="L652"><span class="lineNum"> 652</span> : }</span>
<span id="L653"><span class="lineNum"> 653</span> : </span>
<span id="L654"><span class="lineNum"> 654</span> : constexpr _Float32</span>
<span id="L655"><span class="lineNum"> 655</span> : pow(_Float32 __x, _Float32 __y)</span>
<span id="L656"><span class="lineNum"> 656</span> : { return __builtin_powf(__x, __y); }</span>
<span id="L657"><span class="lineNum"> 657</span> : </span>
<span id="L658"><span class="lineNum"> 658</span> : constexpr _Float32</span>
<span id="L659"><span class="lineNum"> 659</span> : sin(_Float32 __x)</span>
<span id="L660"><span class="lineNum"> 660</span> : { return __builtin_sinf(__x); }</span>
<span id="L661"><span class="lineNum"> 661</span> : </span>
<span id="L662"><span class="lineNum"> 662</span> : constexpr _Float32</span>
<span id="L663"><span class="lineNum"> 663</span> : sinh(_Float32 __x)</span>
<span id="L664"><span class="lineNum"> 664</span> : { return __builtin_sinhf(__x); }</span>
<span id="L665"><span class="lineNum"> 665</span> : </span>
<span id="L666"><span class="lineNum"> 666</span> : constexpr _Float32</span>
<span id="L667"><span class="lineNum"> 667</span> : sqrt(_Float32 __x)</span>
<span id="L668"><span class="lineNum"> 668</span> : { return __builtin_sqrtf(__x); }</span>
<span id="L669"><span class="lineNum"> 669</span> : </span>
<span id="L670"><span class="lineNum"> 670</span> : constexpr _Float32</span>
<span id="L671"><span class="lineNum"> 671</span> : tan(_Float32 __x)</span>
<span id="L672"><span class="lineNum"> 672</span> : { return __builtin_tanf(__x); }</span>
<span id="L673"><span class="lineNum"> 673</span> : </span>
<span id="L674"><span class="lineNum"> 674</span> : constexpr _Float32</span>
<span id="L675"><span class="lineNum"> 675</span> : tanh(_Float32 __x)</span>
<span id="L676"><span class="lineNum"> 676</span> : { return __builtin_tanhf(__x); }</span>
<span id="L677"><span class="lineNum"> 677</span> : #endif</span>
<span id="L678"><span class="lineNum"> 678</span> : </span>
<span id="L679"><span class="lineNum"> 679</span> : #if defined(__STDCPP_FLOAT64_T__) &amp;&amp; defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)</span>
<span id="L680"><span class="lineNum"> 680</span> : constexpr _Float64</span>
<span id="L681"><span class="lineNum"> 681</span> : acos(_Float64 __x)</span>
<span id="L682"><span class="lineNum"> 682</span> : { return __builtin_acos(__x); }</span>
<span id="L683"><span class="lineNum"> 683</span> : </span>
<span id="L684"><span class="lineNum"> 684</span> : constexpr _Float64</span>
<span id="L685"><span class="lineNum"> 685</span> : asin(_Float64 __x)</span>
<span id="L686"><span class="lineNum"> 686</span> : { return __builtin_asin(__x); }</span>
<span id="L687"><span class="lineNum"> 687</span> : </span>
<span id="L688"><span class="lineNum"> 688</span> : constexpr _Float64</span>
<span id="L689"><span class="lineNum"> 689</span> : atan(_Float64 __x)</span>
<span id="L690"><span class="lineNum"> 690</span> : { return __builtin_atan(__x); }</span>
<span id="L691"><span class="lineNum"> 691</span> : </span>
<span id="L692"><span class="lineNum"> 692</span> : constexpr _Float64</span>
<span id="L693"><span class="lineNum"> 693</span> : atan2(_Float64 __y, _Float64 __x)</span>
<span id="L694"><span class="lineNum"> 694</span> : { return __builtin_atan2(__y, __x); }</span>
<span id="L695"><span class="lineNum"> 695</span> : </span>
<span id="L696"><span class="lineNum"> 696</span> : constexpr _Float64</span>
<span id="L697"><span class="lineNum"> 697</span> : ceil(_Float64 __x)</span>
<span id="L698"><span class="lineNum"> 698</span> : { return __builtin_ceil(__x); }</span>
<span id="L699"><span class="lineNum"> 699</span> : </span>
<span id="L700"><span class="lineNum"> 700</span> : constexpr _Float64</span>
<span id="L701"><span class="lineNum"> 701</span> : cos(_Float64 __x)</span>
<span id="L702"><span class="lineNum"> 702</span> : { return __builtin_cos(__x); }</span>
<span id="L703"><span class="lineNum"> 703</span> : </span>
<span id="L704"><span class="lineNum"> 704</span> : constexpr _Float64</span>
<span id="L705"><span class="lineNum"> 705</span> : cosh(_Float64 __x)</span>
<span id="L706"><span class="lineNum"> 706</span> : { return __builtin_cosh(__x); }</span>
<span id="L707"><span class="lineNum"> 707</span> : </span>
<span id="L708"><span class="lineNum"> 708</span> : constexpr _Float64</span>
<span id="L709"><span class="lineNum"> 709</span> : exp(_Float64 __x)</span>
<span id="L710"><span class="lineNum"> 710</span> : { return __builtin_exp(__x); }</span>
<span id="L711"><span class="lineNum"> 711</span> : </span>
<span id="L712"><span class="lineNum"> 712</span> : constexpr _Float64</span>
<span id="L713"><span class="lineNum"> 713</span> : fabs(_Float64 __x)</span>
<span id="L714"><span class="lineNum"> 714</span> : { return __builtin_fabs(__x); }</span>
<span id="L715"><span class="lineNum"> 715</span> : </span>
<span id="L716"><span class="lineNum"> 716</span> : constexpr _Float64</span>
<span id="L717"><span class="lineNum"> 717</span> : floor(_Float64 __x)</span>
<span id="L718"><span class="lineNum"> 718</span> : { return __builtin_floor(__x); }</span>
<span id="L719"><span class="lineNum"> 719</span> : </span>
<span id="L720"><span class="lineNum"> 720</span> : constexpr _Float64</span>
<span id="L721"><span class="lineNum"> 721</span> : fmod(_Float64 __x, _Float64 __y)</span>
<span id="L722"><span class="lineNum"> 722</span> : { return __builtin_fmod(__x, __y); }</span>
<span id="L723"><span class="lineNum"> 723</span> : </span>
<span id="L724"><span class="lineNum"> 724</span> : inline _Float64</span>
<span id="L725"><span class="lineNum"> 725</span> : frexp(_Float64 __x, int* __exp)</span>
<span id="L726"><span class="lineNum"> 726</span> : { return __builtin_frexp(__x, __exp); }</span>
<span id="L727"><span class="lineNum"> 727</span> : </span>
<span id="L728"><span class="lineNum"> 728</span> : constexpr _Float64</span>
<span id="L729"><span class="lineNum"> 729</span> : ldexp(_Float64 __x, int __exp)</span>
<span id="L730"><span class="lineNum"> 730</span> : { return __builtin_ldexp(__x, __exp); }</span>
<span id="L731"><span class="lineNum"> 731</span> : </span>
<span id="L732"><span class="lineNum"> 732</span> : constexpr _Float64</span>
<span id="L733"><span class="lineNum"> 733</span> : log(_Float64 __x)</span>
<span id="L734"><span class="lineNum"> 734</span> : { return __builtin_log(__x); }</span>
<span id="L735"><span class="lineNum"> 735</span> : </span>
<span id="L736"><span class="lineNum"> 736</span> : constexpr _Float64</span>
<span id="L737"><span class="lineNum"> 737</span> : log10(_Float64 __x)</span>
<span id="L738"><span class="lineNum"> 738</span> : { return __builtin_log10(__x); }</span>
<span id="L739"><span class="lineNum"> 739</span> : </span>
<span id="L740"><span class="lineNum"> 740</span> : inline _Float64</span>
<span id="L741"><span class="lineNum"> 741</span> : modf(_Float64 __x, _Float64* __iptr)</span>
<span id="L742"><span class="lineNum"> 742</span> : {</span>
<span id="L743"><span class="lineNum"> 743</span> : double __i, __ret = __builtin_modf(__x, &amp;__i);</span>
<span id="L744"><span class="lineNum"> 744</span> : *__iptr = __i;</span>
<span id="L745"><span class="lineNum"> 745</span> : return __ret;</span>
<span id="L746"><span class="lineNum"> 746</span> : }</span>
<span id="L747"><span class="lineNum"> 747</span> : </span>
<span id="L748"><span class="lineNum"> 748</span> : constexpr _Float64</span>
<span id="L749"><span class="lineNum"> 749</span> : pow(_Float64 __x, _Float64 __y)</span>
<span id="L750"><span class="lineNum"> 750</span> : { return __builtin_pow(__x, __y); }</span>
<span id="L751"><span class="lineNum"> 751</span> : </span>
<span id="L752"><span class="lineNum"> 752</span> : constexpr _Float64</span>
<span id="L753"><span class="lineNum"> 753</span> : sin(_Float64 __x)</span>
<span id="L754"><span class="lineNum"> 754</span> : { return __builtin_sin(__x); }</span>
<span id="L755"><span class="lineNum"> 755</span> : </span>
<span id="L756"><span class="lineNum"> 756</span> : constexpr _Float64</span>
<span id="L757"><span class="lineNum"> 757</span> : sinh(_Float64 __x)</span>
<span id="L758"><span class="lineNum"> 758</span> : { return __builtin_sinh(__x); }</span>
<span id="L759"><span class="lineNum"> 759</span> : </span>
<span id="L760"><span class="lineNum"> 760</span> : constexpr _Float64</span>
<span id="L761"><span class="lineNum"> 761</span> : sqrt(_Float64 __x)</span>
<span id="L762"><span class="lineNum"> 762</span> : { return __builtin_sqrt(__x); }</span>
<span id="L763"><span class="lineNum"> 763</span> : </span>
<span id="L764"><span class="lineNum"> 764</span> : constexpr _Float64</span>
<span id="L765"><span class="lineNum"> 765</span> : tan(_Float64 __x)</span>
<span id="L766"><span class="lineNum"> 766</span> : { return __builtin_tan(__x); }</span>
<span id="L767"><span class="lineNum"> 767</span> : </span>
<span id="L768"><span class="lineNum"> 768</span> : constexpr _Float64</span>
<span id="L769"><span class="lineNum"> 769</span> : tanh(_Float64 __x)</span>
<span id="L770"><span class="lineNum"> 770</span> : { return __builtin_tanh(__x); }</span>
<span id="L771"><span class="lineNum"> 771</span> : #endif</span>
<span id="L772"><span class="lineNum"> 772</span> : </span>
<span id="L773"><span class="lineNum"> 773</span> : #if defined(__STDCPP_FLOAT128_T__) &amp;&amp; defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128)</span>
<span id="L774"><span class="lineNum"> 774</span> : constexpr _Float128</span>
<span id="L775"><span class="lineNum"> 775</span> : acos(_Float128 __x)</span>
<span id="L776"><span class="lineNum"> 776</span> : { return __builtin_acosl(__x); }</span>
<span id="L777"><span class="lineNum"> 777</span> : </span>
<span id="L778"><span class="lineNum"> 778</span> : constexpr _Float128</span>
<span id="L779"><span class="lineNum"> 779</span> : asin(_Float128 __x)</span>
<span id="L780"><span class="lineNum"> 780</span> : { return __builtin_asinl(__x); }</span>
<span id="L781"><span class="lineNum"> 781</span> : </span>
<span id="L782"><span class="lineNum"> 782</span> : constexpr _Float128</span>
<span id="L783"><span class="lineNum"> 783</span> : atan(_Float128 __x)</span>
<span id="L784"><span class="lineNum"> 784</span> : { return __builtin_atanl(__x); }</span>
<span id="L785"><span class="lineNum"> 785</span> : </span>
<span id="L786"><span class="lineNum"> 786</span> : constexpr _Float128</span>
<span id="L787"><span class="lineNum"> 787</span> : atan2(_Float128 __y, _Float128 __x)</span>
<span id="L788"><span class="lineNum"> 788</span> : { return __builtin_atan2l(__y, __x); }</span>
<span id="L789"><span class="lineNum"> 789</span> : </span>
<span id="L790"><span class="lineNum"> 790</span> : constexpr _Float128</span>
<span id="L791"><span class="lineNum"> 791</span> : ceil(_Float128 __x)</span>
<span id="L792"><span class="lineNum"> 792</span> : { return __builtin_ceill(__x); }</span>
<span id="L793"><span class="lineNum"> 793</span> : </span>
<span id="L794"><span class="lineNum"> 794</span> : constexpr _Float128</span>
<span id="L795"><span class="lineNum"> 795</span> : cos(_Float128 __x)</span>
<span id="L796"><span class="lineNum"> 796</span> : { return __builtin_cosl(__x); }</span>
<span id="L797"><span class="lineNum"> 797</span> : </span>
<span id="L798"><span class="lineNum"> 798</span> : constexpr _Float128</span>
<span id="L799"><span class="lineNum"> 799</span> : cosh(_Float128 __x)</span>
<span id="L800"><span class="lineNum"> 800</span> : { return __builtin_coshl(__x); }</span>
<span id="L801"><span class="lineNum"> 801</span> : </span>
<span id="L802"><span class="lineNum"> 802</span> : constexpr _Float128</span>
<span id="L803"><span class="lineNum"> 803</span> : exp(_Float128 __x)</span>
<span id="L804"><span class="lineNum"> 804</span> : { return __builtin_expl(__x); }</span>
<span id="L805"><span class="lineNum"> 805</span> : </span>
<span id="L806"><span class="lineNum"> 806</span> : constexpr _Float128</span>
<span id="L807"><span class="lineNum"> 807</span> : fabs(_Float128 __x)</span>
<span id="L808"><span class="lineNum"> 808</span> : { return __builtin_fabsl(__x); }</span>
<span id="L809"><span class="lineNum"> 809</span> : </span>
<span id="L810"><span class="lineNum"> 810</span> : constexpr _Float128</span>
<span id="L811"><span class="lineNum"> 811</span> : floor(_Float128 __x)</span>
<span id="L812"><span class="lineNum"> 812</span> : { return __builtin_floorl(__x); }</span>
<span id="L813"><span class="lineNum"> 813</span> : </span>
<span id="L814"><span class="lineNum"> 814</span> : constexpr _Float128</span>
<span id="L815"><span class="lineNum"> 815</span> : fmod(_Float128 __x, _Float128 __y)</span>
<span id="L816"><span class="lineNum"> 816</span> : { return __builtin_fmodl(__x, __y); }</span>
<span id="L817"><span class="lineNum"> 817</span> : </span>
<span id="L818"><span class="lineNum"> 818</span> : inline _Float128</span>
<span id="L819"><span class="lineNum"> 819</span> : frexp(_Float128 __x, int* __exp)</span>
<span id="L820"><span class="lineNum"> 820</span> : { return __builtin_frexpl(__x, __exp); }</span>
<span id="L821"><span class="lineNum"> 821</span> : </span>
<span id="L822"><span class="lineNum"> 822</span> : constexpr _Float128</span>
<span id="L823"><span class="lineNum"> 823</span> : ldexp(_Float128 __x, int __exp)</span>
<span id="L824"><span class="lineNum"> 824</span> : { return __builtin_ldexpl(__x, __exp); }</span>
<span id="L825"><span class="lineNum"> 825</span> : </span>
<span id="L826"><span class="lineNum"> 826</span> : constexpr _Float128</span>
<span id="L827"><span class="lineNum"> 827</span> : log(_Float128 __x)</span>
<span id="L828"><span class="lineNum"> 828</span> : { return __builtin_logl(__x); }</span>
<span id="L829"><span class="lineNum"> 829</span> : </span>
<span id="L830"><span class="lineNum"> 830</span> : constexpr _Float128</span>
<span id="L831"><span class="lineNum"> 831</span> : log10(_Float128 __x)</span>
<span id="L832"><span class="lineNum"> 832</span> : { return __builtin_log10l(__x); }</span>
<span id="L833"><span class="lineNum"> 833</span> : </span>
<span id="L834"><span class="lineNum"> 834</span> : inline _Float128</span>
<span id="L835"><span class="lineNum"> 835</span> : modf(_Float128 __x, _Float128* __iptr)</span>
<span id="L836"><span class="lineNum"> 836</span> : {</span>
<span id="L837"><span class="lineNum"> 837</span> : long double __i, __ret = __builtin_modfl(__x, &amp;__i);</span>
<span id="L838"><span class="lineNum"> 838</span> : *__iptr = __i;</span>
<span id="L839"><span class="lineNum"> 839</span> : return __ret;</span>
<span id="L840"><span class="lineNum"> 840</span> : }</span>
<span id="L841"><span class="lineNum"> 841</span> : </span>
<span id="L842"><span class="lineNum"> 842</span> : constexpr _Float128</span>
<span id="L843"><span class="lineNum"> 843</span> : pow(_Float128 __x, _Float128 __y)</span>
<span id="L844"><span class="lineNum"> 844</span> : { return __builtin_powl(__x, __y); }</span>
<span id="L845"><span class="lineNum"> 845</span> : </span>
<span id="L846"><span class="lineNum"> 846</span> : constexpr _Float128</span>
<span id="L847"><span class="lineNum"> 847</span> : sin(_Float128 __x)</span>
<span id="L848"><span class="lineNum"> 848</span> : { return __builtin_sinl(__x); }</span>
<span id="L849"><span class="lineNum"> 849</span> : </span>
<span id="L850"><span class="lineNum"> 850</span> : constexpr _Float128</span>
<span id="L851"><span class="lineNum"> 851</span> : sinh(_Float128 __x)</span>
<span id="L852"><span class="lineNum"> 852</span> : { return __builtin_sinhl(__x); }</span>
<span id="L853"><span class="lineNum"> 853</span> : </span>
<span id="L854"><span class="lineNum"> 854</span> : constexpr _Float128</span>
<span id="L855"><span class="lineNum"> 855</span> : sqrt(_Float128 __x)</span>
<span id="L856"><span class="lineNum"> 856</span> : { return __builtin_sqrtl(__x); }</span>
<span id="L857"><span class="lineNum"> 857</span> : </span>
<span id="L858"><span class="lineNum"> 858</span> : constexpr _Float128</span>
<span id="L859"><span class="lineNum"> 859</span> : tan(_Float128 __x)</span>
<span id="L860"><span class="lineNum"> 860</span> : { return __builtin_tanl(__x); }</span>
<span id="L861"><span class="lineNum"> 861</span> : </span>
<span id="L862"><span class="lineNum"> 862</span> : constexpr _Float128</span>
<span id="L863"><span class="lineNum"> 863</span> : tanh(_Float128 __x)</span>
<span id="L864"><span class="lineNum"> 864</span> : { return __builtin_tanhl(__x); }</span>
<span id="L865"><span class="lineNum"> 865</span> : #elif defined(__STDCPP_FLOAT128_T__) &amp;&amp; defined(_GLIBCXX_HAVE_FLOAT128_MATH)</span>
<span id="L866"><span class="lineNum"> 866</span> : constexpr _Float128</span>
<span id="L867"><span class="lineNum"> 867</span> : acos(_Float128 __x)</span>
<span id="L868"><span class="lineNum"> 868</span> : { return __builtin_acosf128(__x); }</span>
<span id="L869"><span class="lineNum"> 869</span> : </span>
<span id="L870"><span class="lineNum"> 870</span> : constexpr _Float128</span>
<span id="L871"><span class="lineNum"> 871</span> : asin(_Float128 __x)</span>
<span id="L872"><span class="lineNum"> 872</span> : { return __builtin_asinf128(__x); }</span>
<span id="L873"><span class="lineNum"> 873</span> : </span>
<span id="L874"><span class="lineNum"> 874</span> : constexpr _Float128</span>
<span id="L875"><span class="lineNum"> 875</span> : atan(_Float128 __x)</span>
<span id="L876"><span class="lineNum"> 876</span> : { return __builtin_atanf128(__x); }</span>
<span id="L877"><span class="lineNum"> 877</span> : </span>
<span id="L878"><span class="lineNum"> 878</span> : constexpr _Float128</span>
<span id="L879"><span class="lineNum"> 879</span> : atan2(_Float128 __y, _Float128 __x)</span>
<span id="L880"><span class="lineNum"> 880</span> : { return __builtin_atan2f128(__y, __x); }</span>
<span id="L881"><span class="lineNum"> 881</span> : </span>
<span id="L882"><span class="lineNum"> 882</span> : constexpr _Float128</span>
<span id="L883"><span class="lineNum"> 883</span> : ceil(_Float128 __x)</span>
<span id="L884"><span class="lineNum"> 884</span> : { return __builtin_ceilf128(__x); }</span>
<span id="L885"><span class="lineNum"> 885</span> : </span>
<span id="L886"><span class="lineNum"> 886</span> : constexpr _Float128</span>
<span id="L887"><span class="lineNum"> 887</span> : cos(_Float128 __x)</span>
<span id="L888"><span class="lineNum"> 888</span> : { return __builtin_cosf128(__x); }</span>
<span id="L889"><span class="lineNum"> 889</span> : </span>
<span id="L890"><span class="lineNum"> 890</span> : constexpr _Float128</span>
<span id="L891"><span class="lineNum"> 891</span> : cosh(_Float128 __x)</span>
<span id="L892"><span class="lineNum"> 892</span> : { return __builtin_coshf128(__x); }</span>
<span id="L893"><span class="lineNum"> 893</span> : </span>
<span id="L894"><span class="lineNum"> 894</span> : constexpr _Float128</span>
<span id="L895"><span class="lineNum"> 895</span> : exp(_Float128 __x)</span>
<span id="L896"><span class="lineNum"> 896</span> : { return __builtin_expf128(__x); }</span>
<span id="L897"><span class="lineNum"> 897</span> : </span>
<span id="L898"><span class="lineNum"> 898</span> : constexpr _Float128</span>
<span id="L899"><span class="lineNum"> 899</span> : fabs(_Float128 __x)</span>
<span id="L900"><span class="lineNum"> 900</span> : { return __builtin_fabsf128(__x); }</span>
<span id="L901"><span class="lineNum"> 901</span> : </span>
<span id="L902"><span class="lineNum"> 902</span> : constexpr _Float128</span>
<span id="L903"><span class="lineNum"> 903</span> : floor(_Float128 __x)</span>
<span id="L904"><span class="lineNum"> 904</span> : { return __builtin_floorf128(__x); }</span>
<span id="L905"><span class="lineNum"> 905</span> : </span>
<span id="L906"><span class="lineNum"> 906</span> : constexpr _Float128</span>
<span id="L907"><span class="lineNum"> 907</span> : fmod(_Float128 __x, _Float128 __y)</span>
<span id="L908"><span class="lineNum"> 908</span> : { return __builtin_fmodf128(__x, __y); }</span>
<span id="L909"><span class="lineNum"> 909</span> : </span>
<span id="L910"><span class="lineNum"> 910</span> : inline _Float128</span>
<span id="L911"><span class="lineNum"> 911</span> : frexp(_Float128 __x, int* __exp)</span>
<span id="L912"><span class="lineNum"> 912</span> : { return __builtin_frexpf128(__x, __exp); }</span>
<span id="L913"><span class="lineNum"> 913</span> : </span>
<span id="L914"><span class="lineNum"> 914</span> : constexpr _Float128</span>
<span id="L915"><span class="lineNum"> 915</span> : ldexp(_Float128 __x, int __exp)</span>
<span id="L916"><span class="lineNum"> 916</span> : { return __builtin_ldexpf128(__x, __exp); }</span>
<span id="L917"><span class="lineNum"> 917</span> : </span>
<span id="L918"><span class="lineNum"> 918</span> : constexpr _Float128</span>
<span id="L919"><span class="lineNum"> 919</span> : log(_Float128 __x)</span>
<span id="L920"><span class="lineNum"> 920</span> : { return __builtin_logf128(__x); }</span>
<span id="L921"><span class="lineNum"> 921</span> : </span>
<span id="L922"><span class="lineNum"> 922</span> : constexpr _Float128</span>
<span id="L923"><span class="lineNum"> 923</span> : log10(_Float128 __x)</span>
<span id="L924"><span class="lineNum"> 924</span> : { return __builtin_log10f128(__x); }</span>
<span id="L925"><span class="lineNum"> 925</span> : </span>
<span id="L926"><span class="lineNum"> 926</span> : inline _Float128</span>
<span id="L927"><span class="lineNum"> 927</span> : modf(_Float128 __x, _Float128* __iptr)</span>
<span id="L928"><span class="lineNum"> 928</span> : { return __builtin_modff128(__x, __iptr); }</span>
<span id="L929"><span class="lineNum"> 929</span> : </span>
<span id="L930"><span class="lineNum"> 930</span> : constexpr _Float128</span>
<span id="L931"><span class="lineNum"> 931</span> : pow(_Float128 __x, _Float128 __y)</span>
<span id="L932"><span class="lineNum"> 932</span> : { return __builtin_powf128(__x, __y); }</span>
<span id="L933"><span class="lineNum"> 933</span> : </span>
<span id="L934"><span class="lineNum"> 934</span> : constexpr _Float128</span>
<span id="L935"><span class="lineNum"> 935</span> : sin(_Float128 __x)</span>
<span id="L936"><span class="lineNum"> 936</span> : { return __builtin_sinf128(__x); }</span>
<span id="L937"><span class="lineNum"> 937</span> : </span>
<span id="L938"><span class="lineNum"> 938</span> : constexpr _Float128</span>
<span id="L939"><span class="lineNum"> 939</span> : sinh(_Float128 __x)</span>
<span id="L940"><span class="lineNum"> 940</span> : { return __builtin_sinhf128(__x); }</span>
<span id="L941"><span class="lineNum"> 941</span> : </span>
<span id="L942"><span class="lineNum"> 942</span> : constexpr _Float128</span>
<span id="L943"><span class="lineNum"> 943</span> : sqrt(_Float128 __x)</span>
<span id="L944"><span class="lineNum"> 944</span> : { return __builtin_sqrtf128(__x); }</span>
<span id="L945"><span class="lineNum"> 945</span> : </span>
<span id="L946"><span class="lineNum"> 946</span> : constexpr _Float128</span>
<span id="L947"><span class="lineNum"> 947</span> : tan(_Float128 __x)</span>
<span id="L948"><span class="lineNum"> 948</span> : { return __builtin_tanf128(__x); }</span>
<span id="L949"><span class="lineNum"> 949</span> : </span>
<span id="L950"><span class="lineNum"> 950</span> : constexpr _Float128</span>
<span id="L951"><span class="lineNum"> 951</span> : tanh(_Float128 __x)</span>
<span id="L952"><span class="lineNum"> 952</span> : { return __builtin_tanhf128(__x); }</span>
<span id="L953"><span class="lineNum"> 953</span> : #endif</span>
<span id="L954"><span class="lineNum"> 954</span> : </span>
<span id="L955"><span class="lineNum"> 955</span> : #if defined(__STDCPP_BFLOAT16_T__) &amp;&amp; defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)</span>
<span id="L956"><span class="lineNum"> 956</span> : constexpr __gnu_cxx::__bfloat16_t</span>
<span id="L957"><span class="lineNum"> 957</span> : acos(__gnu_cxx::__bfloat16_t __x)</span>
<span id="L958"><span class="lineNum"> 958</span> : { return __gnu_cxx::__bfloat16_t(__builtin_acosf(__x)); }</span>
<span id="L959"><span class="lineNum"> 959</span> : </span>
<span id="L960"><span class="lineNum"> 960</span> : constexpr __gnu_cxx::__bfloat16_t</span>
<span id="L961"><span class="lineNum"> 961</span> : asin(__gnu_cxx::__bfloat16_t __x)</span>
<span id="L962"><span class="lineNum"> 962</span> : { return __gnu_cxx::__bfloat16_t(__builtin_asinf(__x)); }</span>
<span id="L963"><span class="lineNum"> 963</span> : </span>
<span id="L964"><span class="lineNum"> 964</span> : constexpr __gnu_cxx::__bfloat16_t</span>
<span id="L965"><span class="lineNum"> 965</span> : atan(__gnu_cxx::__bfloat16_t __x)</span>
<span id="L966"><span class="lineNum"> 966</span> : { return __gnu_cxx::__bfloat16_t(__builtin_atanf(__x)); }</span>
<span id="L967"><span class="lineNum"> 967</span> : </span>
<span id="L968"><span class="lineNum"> 968</span> : constexpr __gnu_cxx::__bfloat16_t</span>
<span id="L969"><span class="lineNum"> 969</span> : atan2(__gnu_cxx::__bfloat16_t __y, __gnu_cxx::__bfloat16_t __x)</span>
<span id="L970"><span class="lineNum"> 970</span> : { return __gnu_cxx::__bfloat16_t(__builtin_atan2f(__y, __x)); }</span>
<span id="L971"><span class="lineNum"> 971</span> : </span>
<span id="L972"><span class="lineNum"> 972</span> : constexpr __gnu_cxx::__bfloat16_t</span>
<span id="L973"><span class="lineNum"> 973</span> : ceil(__gnu_cxx::__bfloat16_t __x)</span>
<span id="L974"><span class="lineNum"> 974</span> : { return __gnu_cxx::__bfloat16_t(__builtin_ceilf(__x)); }</span>
<span id="L975"><span class="lineNum"> 975</span> : </span>
<span id="L976"><span class="lineNum"> 976</span> : constexpr __gnu_cxx::__bfloat16_t</span>
<span id="L977"><span class="lineNum"> 977</span> : cos(__gnu_cxx::__bfloat16_t __x)</span>
<span id="L978"><span class="lineNum"> 978</span> : { return __gnu_cxx::__bfloat16_t(__builtin_cosf(__x)); }</span>
<span id="L979"><span class="lineNum"> 979</span> : </span>
<span id="L980"><span class="lineNum"> 980</span> : constexpr __gnu_cxx::__bfloat16_t</span>
<span id="L981"><span class="lineNum"> 981</span> : cosh(__gnu_cxx::__bfloat16_t __x)</span>
<span id="L982"><span class="lineNum"> 982</span> : { return __gnu_cxx::__bfloat16_t(__builtin_coshf(__x)); }</span>
<span id="L983"><span class="lineNum"> 983</span> : </span>
<span id="L984"><span class="lineNum"> 984</span> : constexpr __gnu_cxx::__bfloat16_t</span>
<span id="L985"><span class="lineNum"> 985</span> : exp(__gnu_cxx::__bfloat16_t __x)</span>
<span id="L986"><span class="lineNum"> 986</span> : { return __gnu_cxx::__bfloat16_t(__builtin_expf(__x)); }</span>
<span id="L987"><span class="lineNum"> 987</span> : </span>
<span id="L988"><span class="lineNum"> 988</span> : constexpr __gnu_cxx::__bfloat16_t</span>
<span id="L989"><span class="lineNum"> 989</span> : fabs(__gnu_cxx::__bfloat16_t __x)</span>
<span id="L990"><span class="lineNum"> 990</span> : { return __gnu_cxx::__bfloat16_t(__builtin_fabsf(__x)); }</span>
<span id="L991"><span class="lineNum"> 991</span> : </span>
<span id="L992"><span class="lineNum"> 992</span> : constexpr __gnu_cxx::__bfloat16_t</span>
<span id="L993"><span class="lineNum"> 993</span> : floor(__gnu_cxx::__bfloat16_t __x)</span>
<span id="L994"><span class="lineNum"> 994</span> : { return __gnu_cxx::__bfloat16_t(__builtin_floorf(__x)); }</span>
<span id="L995"><span class="lineNum"> 995</span> : </span>
<span id="L996"><span class="lineNum"> 996</span> : constexpr __gnu_cxx::__bfloat16_t</span>
<span id="L997"><span class="lineNum"> 997</span> : fmod(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)</span>
<span id="L998"><span class="lineNum"> 998</span> : { return __gnu_cxx::__bfloat16_t(__builtin_fmodf(__x, __y)); }</span>
<span id="L999"><span class="lineNum"> 999</span> : </span>
<span id="L1000"><span class="lineNum"> 1000</span> : inline __gnu_cxx::__bfloat16_t</span>
<span id="L1001"><span class="lineNum"> 1001</span> : frexp(__gnu_cxx::__bfloat16_t __x, int* __exp)</span>
<span id="L1002"><span class="lineNum"> 1002</span> : { return __gnu_cxx::__bfloat16_t(__builtin_frexpf(__x, __exp)); }</span>
<span id="L1003"><span class="lineNum"> 1003</span> : </span>
<span id="L1004"><span class="lineNum"> 1004</span> : constexpr __gnu_cxx::__bfloat16_t</span>
<span id="L1005"><span class="lineNum"> 1005</span> : ldexp(__gnu_cxx::__bfloat16_t __x, int __exp)</span>
<span id="L1006"><span class="lineNum"> 1006</span> : { return __gnu_cxx::__bfloat16_t(__builtin_ldexpf(__x, __exp)); }</span>
<span id="L1007"><span class="lineNum"> 1007</span> : </span>
<span id="L1008"><span class="lineNum"> 1008</span> : constexpr __gnu_cxx::__bfloat16_t</span>
<span id="L1009"><span class="lineNum"> 1009</span> : log(__gnu_cxx::__bfloat16_t __x)</span>
<span id="L1010"><span class="lineNum"> 1010</span> : { return __gnu_cxx::__bfloat16_t(__builtin_logf(__x)); }</span>
<span id="L1011"><span class="lineNum"> 1011</span> : </span>
<span id="L1012"><span class="lineNum"> 1012</span> : constexpr __gnu_cxx::__bfloat16_t</span>
<span id="L1013"><span class="lineNum"> 1013</span> : log10(__gnu_cxx::__bfloat16_t __x)</span>
<span id="L1014"><span class="lineNum"> 1014</span> : { return __gnu_cxx::__bfloat16_t(__builtin_log10f(__x)); }</span>
<span id="L1015"><span class="lineNum"> 1015</span> : </span>
<span id="L1016"><span class="lineNum"> 1016</span> : inline __gnu_cxx::__bfloat16_t</span>
<span id="L1017"><span class="lineNum"> 1017</span> : modf(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t* __iptr)</span>
<span id="L1018"><span class="lineNum"> 1018</span> : {</span>
<span id="L1019"><span class="lineNum"> 1019</span> : float __i, __ret = __builtin_modff(__x, &amp;__i);</span>
<span id="L1020"><span class="lineNum"> 1020</span> : *__iptr = __gnu_cxx::__bfloat16_t(__i);</span>
<span id="L1021"><span class="lineNum"> 1021</span> : return __gnu_cxx::__bfloat16_t(__ret);</span>
<span id="L1022"><span class="lineNum"> 1022</span> : }</span>
<span id="L1023"><span class="lineNum"> 1023</span> : </span>
<span id="L1024"><span class="lineNum"> 1024</span> : constexpr __gnu_cxx::__bfloat16_t</span>
<span id="L1025"><span class="lineNum"> 1025</span> : pow(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)</span>
<span id="L1026"><span class="lineNum"> 1026</span> : { return __gnu_cxx::__bfloat16_t(__builtin_powf(__x, __y)); }</span>
<span id="L1027"><span class="lineNum"> 1027</span> : </span>
<span id="L1028"><span class="lineNum"> 1028</span> : constexpr __gnu_cxx::__bfloat16_t</span>
<span id="L1029"><span class="lineNum"> 1029</span> : sin(__gnu_cxx::__bfloat16_t __x)</span>
<span id="L1030"><span class="lineNum"> 1030</span> : { return __gnu_cxx::__bfloat16_t(__builtin_sinf(__x)); }</span>
<span id="L1031"><span class="lineNum"> 1031</span> : </span>
<span id="L1032"><span class="lineNum"> 1032</span> : constexpr __gnu_cxx::__bfloat16_t</span>
<span id="L1033"><span class="lineNum"> 1033</span> : sinh(__gnu_cxx::__bfloat16_t __x)</span>
<span id="L1034"><span class="lineNum"> 1034</span> : { return __gnu_cxx::__bfloat16_t(__builtin_sinhf(__x)); }</span>
<span id="L1035"><span class="lineNum"> 1035</span> : </span>
<span id="L1036"><span class="lineNum"> 1036</span> : constexpr __gnu_cxx::__bfloat16_t</span>
<span id="L1037"><span class="lineNum"> 1037</span> : sqrt(__gnu_cxx::__bfloat16_t __x)</span>
<span id="L1038"><span class="lineNum"> 1038</span> : { return __gnu_cxx::__bfloat16_t(__builtin_sqrtf(__x)); }</span>
<span id="L1039"><span class="lineNum"> 1039</span> : </span>
<span id="L1040"><span class="lineNum"> 1040</span> : constexpr __gnu_cxx::__bfloat16_t</span>
<span id="L1041"><span class="lineNum"> 1041</span> : tan(__gnu_cxx::__bfloat16_t __x)</span>
<span id="L1042"><span class="lineNum"> 1042</span> : { return __gnu_cxx::__bfloat16_t(__builtin_tanf(__x)); }</span>
<span id="L1043"><span class="lineNum"> 1043</span> : </span>
<span id="L1044"><span class="lineNum"> 1044</span> : constexpr __gnu_cxx::__bfloat16_t</span>
<span id="L1045"><span class="lineNum"> 1045</span> : tanh(__gnu_cxx::__bfloat16_t __x)</span>
<span id="L1046"><span class="lineNum"> 1046</span> : { return __gnu_cxx::__bfloat16_t(__builtin_tanhf(__x)); }</span>
<span id="L1047"><span class="lineNum"> 1047</span> : #endif</span>
<span id="L1048"><span class="lineNum"> 1048</span> : </span>
<span id="L1049"><span class="lineNum"> 1049</span> : template&lt;typename _Tp, typename _Up&gt;</span>
<span id="L1050"><span class="lineNum"> 1050</span> : inline _GLIBCXX_CONSTEXPR</span>
<span id="L1051"><span class="lineNum"> 1051</span> : typename __gnu_cxx::__promote_2&lt;_Tp, _Up&gt;::__type</span>
<span id="L1052"><span class="lineNum"> 1052</span> : atan2(_Tp __y, _Up __x)</span>
<span id="L1053"><span class="lineNum"> 1053</span> : {</span>
<span id="L1054"><span class="lineNum"> 1054</span> : typedef typename __gnu_cxx::__promote_2&lt;_Tp, _Up&gt;::__type __type;</span>
<span id="L1055"><span class="lineNum"> 1055</span> : return atan2(__type(__y), __type(__x));</span>
<span id="L1056"><span class="lineNum"> 1056</span> : }</span>
<span id="L1057"><span class="lineNum"> 1057</span> : </span>
<span id="L1058"><span class="lineNum"> 1058</span> : template&lt;typename _Tp, typename _Up&gt;</span>
<span id="L1059"><span class="lineNum"> 1059</span> : inline _GLIBCXX_CONSTEXPR</span>
<span id="L1060"><span class="lineNum"> 1060</span> : typename __gnu_cxx::__promote_2&lt;_Tp, _Up&gt;::__type</span>
<span id="L1061"><span class="lineNum"> 1061</span> : fmod(_Tp __x, _Up __y)</span>
<span id="L1062"><span class="lineNum"> 1062</span> : {</span>
<span id="L1063"><span class="lineNum"> 1063</span> : typedef typename __gnu_cxx::__promote_2&lt;_Tp, _Up&gt;::__type __type;</span>
<span id="L1064"><span class="lineNum"> 1064</span> : return fmod(__type(__x), __type(__y));</span>
<span id="L1065"><span class="lineNum"> 1065</span> : }</span>
<span id="L1066"><span class="lineNum"> 1066</span> : </span>
<span id="L1067"><span class="lineNum"> 1067</span> : template&lt;typename _Tp, typename _Up&gt;</span>
<span id="L1068"><span class="lineNum"> 1068</span> : inline _GLIBCXX_CONSTEXPR</span>
<span id="L1069"><span class="lineNum"> 1069</span> : typename __gnu_cxx::__promote_2&lt;_Tp, _Up&gt;::__type</span>
<span id="L1070"><span class="lineNum"> 1070</span> : pow(_Tp __x, _Up __y)</span>
<span id="L1071"><span class="lineNum"> 1071</span> : {</span>
<span id="L1072"><span class="lineNum"> 1072</span> : typedef typename __gnu_cxx::__promote_2&lt;_Tp, _Up&gt;::__type __type;</span>
<span id="L1073"><span class="lineNum"> 1073</span> : return pow(__type(__x), __type(__y));</span>
<span id="L1074"><span class="lineNum"> 1074</span> : }</span>
<span id="L1075"><span class="lineNum"> 1075</span> : </span>
<span id="L1076"><span class="lineNum"> 1076</span> : #if _GLIBCXX_USE_C99_MATH</span>
<span id="L1077"><span class="lineNum"> 1077</span> : #if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC</span>
<span id="L1078"><span class="lineNum"> 1078</span> : </span>
<span id="L1079"><span class="lineNum"> 1079</span> : // These are possible macros imported from C99-land.</span>
<span id="L1080"><span class="lineNum"> 1080</span> : #undef fpclassify</span>
<span id="L1081"><span class="lineNum"> 1081</span> : #undef isfinite</span>
<span id="L1082"><span class="lineNum"> 1082</span> : #undef isinf</span>
<span id="L1083"><span class="lineNum"> 1083</span> : #undef isnan</span>
<span id="L1084"><span class="lineNum"> 1084</span> : #undef isnormal</span>
<span id="L1085"><span class="lineNum"> 1085</span> : #undef signbit</span>
<span id="L1086"><span class="lineNum"> 1086</span> : #undef isgreater</span>
<span id="L1087"><span class="lineNum"> 1087</span> : #undef isgreaterequal</span>
<span id="L1088"><span class="lineNum"> 1088</span> : #undef isless</span>
<span id="L1089"><span class="lineNum"> 1089</span> : #undef islessequal</span>
<span id="L1090"><span class="lineNum"> 1090</span> : #undef islessgreater</span>
<span id="L1091"><span class="lineNum"> 1091</span> : #undef isunordered</span>
<span id="L1092"><span class="lineNum"> 1092</span> : </span>
<span id="L1093"><span class="lineNum"> 1093</span> : #if __cplusplus &gt;= 201103L</span>
<span id="L1094"><span class="lineNum"> 1094</span> : </span>
<span id="L1095"><span class="lineNum"> 1095</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP</span>
<span id="L1096"><span class="lineNum"> 1096</span> : constexpr int</span>
<span id="L1097"><span class="lineNum"> 1097</span> : fpclassify(float __x)</span>
<span id="L1098"><span class="lineNum"> 1098</span> : { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,</span>
<span id="L1099"><span class="lineNum"> 1099</span> : FP_SUBNORMAL, FP_ZERO, __x); }</span>
<span id="L1100"><span class="lineNum"> 1100</span> : </span>
<span id="L1101"><span class="lineNum"> 1101</span> : constexpr int</span>
<span id="L1102"><span class="lineNum"> 1102</span> : fpclassify(double __x)</span>
<span id="L1103"><span class="lineNum"> 1103</span> : { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,</span>
<span id="L1104"><span class="lineNum"> 1104</span> : FP_SUBNORMAL, FP_ZERO, __x); }</span>
<span id="L1105"><span class="lineNum"> 1105</span> : </span>
<span id="L1106"><span class="lineNum"> 1106</span> : constexpr int</span>
<span id="L1107"><span class="lineNum"> 1107</span> : fpclassify(long double __x)</span>
<span id="L1108"><span class="lineNum"> 1108</span> : { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,</span>
<span id="L1109"><span class="lineNum"> 1109</span> : FP_SUBNORMAL, FP_ZERO, __x); }</span>
<span id="L1110"><span class="lineNum"> 1110</span> : #endif</span>
<span id="L1111"><span class="lineNum"> 1111</span> : </span>
<span id="L1112"><span class="lineNum"> 1112</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT</span>
<span id="L1113"><span class="lineNum"> 1113</span> : template&lt;typename _Tp&gt;</span>
<span id="L1114"><span class="lineNum"> 1114</span> : constexpr typename __gnu_cxx::__enable_if&lt;__is_integer&lt;_Tp&gt;::__value,</span>
<span id="L1115"><span class="lineNum"> 1115</span> : int&gt;::__type</span>
<span id="L1116"><span class="lineNum"> 1116</span> : fpclassify(_Tp __x)</span>
<span id="L1117"><span class="lineNum"> 1117</span> : { return __x != 0 ? FP_NORMAL : FP_ZERO; }</span>
<span id="L1118"><span class="lineNum"> 1118</span> : #endif</span>
<span id="L1119"><span class="lineNum"> 1119</span> : </span>
<span id="L1120"><span class="lineNum"> 1120</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP</span>
<span id="L1121"><span class="lineNum"> 1121</span> : constexpr bool</span>
<span id="L1122"><span class="lineNum"> 1122</span> : isfinite(float __x)</span>
<span id="L1123"><span class="lineNum"> 1123</span> : { return __builtin_isfinite(__x); }</span>
<span id="L1124"><span class="lineNum"> 1124</span> : </span>
<span id="L1125"><span class="lineNum"> 1125</span> : constexpr bool</span>
<span id="L1126"><span class="lineNum"> 1126</span> <span class="tlaGNC tlaBgGNC"> 32 : isfinite(double __x)</span></span>
<span id="L1127"><span class="lineNum"> 1127</span> <span class="tlaGNC"> 32 : { return __builtin_isfinite(__x); }</span></span>
<span id="L1128"><span class="lineNum"> 1128</span> : </span>
<span id="L1129"><span class="lineNum"> 1129</span> : constexpr bool</span>
<span id="L1130"><span class="lineNum"> 1130</span> : isfinite(long double __x)</span>
<span id="L1131"><span class="lineNum"> 1131</span> : { return __builtin_isfinite(__x); }</span>
<span id="L1132"><span class="lineNum"> 1132</span> : #endif</span>
<span id="L1133"><span class="lineNum"> 1133</span> : </span>
<span id="L1134"><span class="lineNum"> 1134</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT</span>
<span id="L1135"><span class="lineNum"> 1135</span> : template&lt;typename _Tp&gt;</span>
<span id="L1136"><span class="lineNum"> 1136</span> : constexpr typename __gnu_cxx::__enable_if&lt;__is_integer&lt;_Tp&gt;::__value,</span>
<span id="L1137"><span class="lineNum"> 1137</span> : bool&gt;::__type</span>
<span id="L1138"><span class="lineNum"> 1138</span> : isfinite(_Tp)</span>
<span id="L1139"><span class="lineNum"> 1139</span> : { return true; }</span>
<span id="L1140"><span class="lineNum"> 1140</span> : #endif</span>
<span id="L1141"><span class="lineNum"> 1141</span> : </span>
<span id="L1142"><span class="lineNum"> 1142</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP</span>
<span id="L1143"><span class="lineNum"> 1143</span> : constexpr bool</span>
<span id="L1144"><span class="lineNum"> 1144</span> : isinf(float __x)</span>
<span id="L1145"><span class="lineNum"> 1145</span> : { return __builtin_isinf(__x); }</span>
<span id="L1146"><span class="lineNum"> 1146</span> : </span>
<span id="L1147"><span class="lineNum"> 1147</span> : #if _GLIBCXX_HAVE_OBSOLETE_ISINF \</span>
<span id="L1148"><span class="lineNum"> 1148</span> : &amp;&amp; !_GLIBCXX_NO_OBSOLETE_ISINF_ISNAN_DYNAMIC</span>
<span id="L1149"><span class="lineNum"> 1149</span> : using ::isinf;</span>
<span id="L1150"><span class="lineNum"> 1150</span> : #else</span>
<span id="L1151"><span class="lineNum"> 1151</span> : constexpr bool</span>
<span id="L1152"><span class="lineNum"> 1152</span> : isinf(double __x)</span>
<span id="L1153"><span class="lineNum"> 1153</span> : { return __builtin_isinf(__x); }</span>
<span id="L1154"><span class="lineNum"> 1154</span> : #endif</span>
<span id="L1155"><span class="lineNum"> 1155</span> : </span>
<span id="L1156"><span class="lineNum"> 1156</span> : constexpr bool</span>
<span id="L1157"><span class="lineNum"> 1157</span> : isinf(long double __x)</span>
<span id="L1158"><span class="lineNum"> 1158</span> : { return __builtin_isinf(__x); }</span>
<span id="L1159"><span class="lineNum"> 1159</span> : #endif</span>
<span id="L1160"><span class="lineNum"> 1160</span> : </span>
<span id="L1161"><span class="lineNum"> 1161</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT</span>
<span id="L1162"><span class="lineNum"> 1162</span> : template&lt;typename _Tp&gt;</span>
<span id="L1163"><span class="lineNum"> 1163</span> : constexpr typename __gnu_cxx::__enable_if&lt;__is_integer&lt;_Tp&gt;::__value,</span>
<span id="L1164"><span class="lineNum"> 1164</span> : bool&gt;::__type</span>
<span id="L1165"><span class="lineNum"> 1165</span> : isinf(_Tp)</span>
<span id="L1166"><span class="lineNum"> 1166</span> : { return false; }</span>
<span id="L1167"><span class="lineNum"> 1167</span> : #endif</span>
<span id="L1168"><span class="lineNum"> 1168</span> : </span>
<span id="L1169"><span class="lineNum"> 1169</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP</span>
<span id="L1170"><span class="lineNum"> 1170</span> : constexpr bool</span>
<span id="L1171"><span class="lineNum"> 1171</span> : isnan(float __x)</span>
<span id="L1172"><span class="lineNum"> 1172</span> : { return __builtin_isnan(__x); }</span>
<span id="L1173"><span class="lineNum"> 1173</span> : </span>
<span id="L1174"><span class="lineNum"> 1174</span> : #if _GLIBCXX_HAVE_OBSOLETE_ISNAN \</span>
<span id="L1175"><span class="lineNum"> 1175</span> : &amp;&amp; !_GLIBCXX_NO_OBSOLETE_ISINF_ISNAN_DYNAMIC</span>
<span id="L1176"><span class="lineNum"> 1176</span> : using ::isnan;</span>
<span id="L1177"><span class="lineNum"> 1177</span> : #else</span>
<span id="L1178"><span class="lineNum"> 1178</span> : constexpr bool</span>
<span id="L1179"><span class="lineNum"> 1179</span> <span class="tlaUNC tlaBgUNC"> 0 : isnan(double __x)</span></span>
<span id="L1180"><span class="lineNum"> 1180</span> <span class="tlaUNC"> 0 : { return __builtin_isnan(__x); }</span></span>
<span id="L1181"><span class="lineNum"> 1181</span> : #endif</span>
<span id="L1182"><span class="lineNum"> 1182</span> : </span>
<span id="L1183"><span class="lineNum"> 1183</span> : constexpr bool</span>
<span id="L1184"><span class="lineNum"> 1184</span> : isnan(long double __x)</span>
<span id="L1185"><span class="lineNum"> 1185</span> : { return __builtin_isnan(__x); }</span>
<span id="L1186"><span class="lineNum"> 1186</span> : #endif</span>
<span id="L1187"><span class="lineNum"> 1187</span> : </span>
<span id="L1188"><span class="lineNum"> 1188</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT</span>
<span id="L1189"><span class="lineNum"> 1189</span> : template&lt;typename _Tp&gt;</span>
<span id="L1190"><span class="lineNum"> 1190</span> : constexpr typename __gnu_cxx::__enable_if&lt;__is_integer&lt;_Tp&gt;::__value,</span>
<span id="L1191"><span class="lineNum"> 1191</span> : bool&gt;::__type</span>
<span id="L1192"><span class="lineNum"> 1192</span> : isnan(_Tp)</span>
<span id="L1193"><span class="lineNum"> 1193</span> : { return false; }</span>
<span id="L1194"><span class="lineNum"> 1194</span> : #endif</span>
<span id="L1195"><span class="lineNum"> 1195</span> : </span>
<span id="L1196"><span class="lineNum"> 1196</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP</span>
<span id="L1197"><span class="lineNum"> 1197</span> : constexpr bool</span>
<span id="L1198"><span class="lineNum"> 1198</span> : isnormal(float __x)</span>
<span id="L1199"><span class="lineNum"> 1199</span> : { return __builtin_isnormal(__x); }</span>
<span id="L1200"><span class="lineNum"> 1200</span> : </span>
<span id="L1201"><span class="lineNum"> 1201</span> : constexpr bool</span>
<span id="L1202"><span class="lineNum"> 1202</span> : isnormal(double __x)</span>
<span id="L1203"><span class="lineNum"> 1203</span> : { return __builtin_isnormal(__x); }</span>
<span id="L1204"><span class="lineNum"> 1204</span> : </span>
<span id="L1205"><span class="lineNum"> 1205</span> : constexpr bool</span>
<span id="L1206"><span class="lineNum"> 1206</span> : isnormal(long double __x)</span>
<span id="L1207"><span class="lineNum"> 1207</span> : { return __builtin_isnormal(__x); }</span>
<span id="L1208"><span class="lineNum"> 1208</span> : #endif</span>
<span id="L1209"><span class="lineNum"> 1209</span> : </span>
<span id="L1210"><span class="lineNum"> 1210</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT</span>
<span id="L1211"><span class="lineNum"> 1211</span> : template&lt;typename _Tp&gt;</span>
<span id="L1212"><span class="lineNum"> 1212</span> : constexpr typename __gnu_cxx::__enable_if&lt;__is_integer&lt;_Tp&gt;::__value,</span>
<span id="L1213"><span class="lineNum"> 1213</span> : bool&gt;::__type</span>
<span id="L1214"><span class="lineNum"> 1214</span> : isnormal(_Tp __x)</span>
<span id="L1215"><span class="lineNum"> 1215</span> : { return __x != 0 ? true : false; }</span>
<span id="L1216"><span class="lineNum"> 1216</span> : #endif</span>
<span id="L1217"><span class="lineNum"> 1217</span> : </span>
<span id="L1218"><span class="lineNum"> 1218</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP</span>
<span id="L1219"><span class="lineNum"> 1219</span> : // Note: middle-end/36757 is fixed, __builtin_signbit is type-generic.</span>
<span id="L1220"><span class="lineNum"> 1220</span> : constexpr bool</span>
<span id="L1221"><span class="lineNum"> 1221</span> : signbit(float __x)</span>
<span id="L1222"><span class="lineNum"> 1222</span> : { return __builtin_signbit(__x); }</span>
<span id="L1223"><span class="lineNum"> 1223</span> : </span>
<span id="L1224"><span class="lineNum"> 1224</span> : constexpr bool</span>
<span id="L1225"><span class="lineNum"> 1225</span> <span class="tlaGNC tlaBgGNC"> 8 : signbit(double __x)</span></span>
<span id="L1226"><span class="lineNum"> 1226</span> <span class="tlaGNC"> 8 : { return __builtin_signbit(__x); }</span></span>
<span id="L1227"><span class="lineNum"> 1227</span> : </span>
<span id="L1228"><span class="lineNum"> 1228</span> : constexpr bool</span>
<span id="L1229"><span class="lineNum"> 1229</span> : signbit(long double __x)</span>
<span id="L1230"><span class="lineNum"> 1230</span> : { return __builtin_signbit(__x); }</span>
<span id="L1231"><span class="lineNum"> 1231</span> : #endif</span>
<span id="L1232"><span class="lineNum"> 1232</span> : </span>
<span id="L1233"><span class="lineNum"> 1233</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT</span>
<span id="L1234"><span class="lineNum"> 1234</span> : template&lt;typename _Tp&gt;</span>
<span id="L1235"><span class="lineNum"> 1235</span> : constexpr typename __gnu_cxx::__enable_if&lt;__is_integer&lt;_Tp&gt;::__value,</span>
<span id="L1236"><span class="lineNum"> 1236</span> : bool&gt;::__type</span>
<span id="L1237"><span class="lineNum"> 1237</span> : signbit(_Tp __x)</span>
<span id="L1238"><span class="lineNum"> 1238</span> : { return __x &lt; 0 ? true : false; }</span>
<span id="L1239"><span class="lineNum"> 1239</span> : #endif</span>
<span id="L1240"><span class="lineNum"> 1240</span> : </span>
<span id="L1241"><span class="lineNum"> 1241</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP</span>
<span id="L1242"><span class="lineNum"> 1242</span> : constexpr bool</span>
<span id="L1243"><span class="lineNum"> 1243</span> : isgreater(float __x, float __y)</span>
<span id="L1244"><span class="lineNum"> 1244</span> : { return __builtin_isgreater(__x, __y); }</span>
<span id="L1245"><span class="lineNum"> 1245</span> : </span>
<span id="L1246"><span class="lineNum"> 1246</span> : constexpr bool</span>
<span id="L1247"><span class="lineNum"> 1247</span> : isgreater(double __x, double __y)</span>
<span id="L1248"><span class="lineNum"> 1248</span> : { return __builtin_isgreater(__x, __y); }</span>
<span id="L1249"><span class="lineNum"> 1249</span> : </span>
<span id="L1250"><span class="lineNum"> 1250</span> : constexpr bool</span>
<span id="L1251"><span class="lineNum"> 1251</span> : isgreater(long double __x, long double __y)</span>
<span id="L1252"><span class="lineNum"> 1252</span> : { return __builtin_isgreater(__x, __y); }</span>
<span id="L1253"><span class="lineNum"> 1253</span> : #endif</span>
<span id="L1254"><span class="lineNum"> 1254</span> : </span>
<span id="L1255"><span class="lineNum"> 1255</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT</span>
<span id="L1256"><span class="lineNum"> 1256</span> : template&lt;typename _Tp, typename _Up&gt;</span>
<span id="L1257"><span class="lineNum"> 1257</span> : constexpr typename</span>
<span id="L1258"><span class="lineNum"> 1258</span> : __gnu_cxx::__enable_if&lt;(__is_arithmetic&lt;_Tp&gt;::__value</span>
<span id="L1259"><span class="lineNum"> 1259</span> : &amp;&amp; __is_arithmetic&lt;_Up&gt;::__value), bool&gt;::__type</span>
<span id="L1260"><span class="lineNum"> 1260</span> : isgreater(_Tp __x, _Up __y)</span>
<span id="L1261"><span class="lineNum"> 1261</span> : {</span>
<span id="L1262"><span class="lineNum"> 1262</span> : typedef typename __gnu_cxx::__promote_2&lt;_Tp, _Up&gt;::__type __type;</span>
<span id="L1263"><span class="lineNum"> 1263</span> : return __builtin_isgreater(__type(__x), __type(__y));</span>
<span id="L1264"><span class="lineNum"> 1264</span> : }</span>
<span id="L1265"><span class="lineNum"> 1265</span> : #endif</span>
<span id="L1266"><span class="lineNum"> 1266</span> : </span>
<span id="L1267"><span class="lineNum"> 1267</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP</span>
<span id="L1268"><span class="lineNum"> 1268</span> : constexpr bool</span>
<span id="L1269"><span class="lineNum"> 1269</span> : isgreaterequal(float __x, float __y)</span>
<span id="L1270"><span class="lineNum"> 1270</span> : { return __builtin_isgreaterequal(__x, __y); }</span>
<span id="L1271"><span class="lineNum"> 1271</span> : </span>
<span id="L1272"><span class="lineNum"> 1272</span> : constexpr bool</span>
<span id="L1273"><span class="lineNum"> 1273</span> : isgreaterequal(double __x, double __y)</span>
<span id="L1274"><span class="lineNum"> 1274</span> : { return __builtin_isgreaterequal(__x, __y); }</span>
<span id="L1275"><span class="lineNum"> 1275</span> : </span>
<span id="L1276"><span class="lineNum"> 1276</span> : constexpr bool</span>
<span id="L1277"><span class="lineNum"> 1277</span> : isgreaterequal(long double __x, long double __y)</span>
<span id="L1278"><span class="lineNum"> 1278</span> : { return __builtin_isgreaterequal(__x, __y); }</span>
<span id="L1279"><span class="lineNum"> 1279</span> : #endif</span>
<span id="L1280"><span class="lineNum"> 1280</span> : </span>
<span id="L1281"><span class="lineNum"> 1281</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT</span>
<span id="L1282"><span class="lineNum"> 1282</span> : template&lt;typename _Tp, typename _Up&gt;</span>
<span id="L1283"><span class="lineNum"> 1283</span> : constexpr typename</span>
<span id="L1284"><span class="lineNum"> 1284</span> : __gnu_cxx::__enable_if&lt;(__is_arithmetic&lt;_Tp&gt;::__value</span>
<span id="L1285"><span class="lineNum"> 1285</span> : &amp;&amp; __is_arithmetic&lt;_Up&gt;::__value), bool&gt;::__type</span>
<span id="L1286"><span class="lineNum"> 1286</span> : isgreaterequal(_Tp __x, _Up __y)</span>
<span id="L1287"><span class="lineNum"> 1287</span> : {</span>
<span id="L1288"><span class="lineNum"> 1288</span> : typedef typename __gnu_cxx::__promote_2&lt;_Tp, _Up&gt;::__type __type;</span>
<span id="L1289"><span class="lineNum"> 1289</span> : return __builtin_isgreaterequal(__type(__x), __type(__y));</span>
<span id="L1290"><span class="lineNum"> 1290</span> : }</span>
<span id="L1291"><span class="lineNum"> 1291</span> : #endif</span>
<span id="L1292"><span class="lineNum"> 1292</span> : </span>
<span id="L1293"><span class="lineNum"> 1293</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP</span>
<span id="L1294"><span class="lineNum"> 1294</span> : constexpr bool</span>
<span id="L1295"><span class="lineNum"> 1295</span> : isless(float __x, float __y)</span>
<span id="L1296"><span class="lineNum"> 1296</span> : { return __builtin_isless(__x, __y); }</span>
<span id="L1297"><span class="lineNum"> 1297</span> : </span>
<span id="L1298"><span class="lineNum"> 1298</span> : constexpr bool</span>
<span id="L1299"><span class="lineNum"> 1299</span> : isless(double __x, double __y)</span>
<span id="L1300"><span class="lineNum"> 1300</span> : { return __builtin_isless(__x, __y); }</span>
<span id="L1301"><span class="lineNum"> 1301</span> : </span>
<span id="L1302"><span class="lineNum"> 1302</span> : constexpr bool</span>
<span id="L1303"><span class="lineNum"> 1303</span> : isless(long double __x, long double __y)</span>
<span id="L1304"><span class="lineNum"> 1304</span> : { return __builtin_isless(__x, __y); }</span>
<span id="L1305"><span class="lineNum"> 1305</span> : #endif</span>
<span id="L1306"><span class="lineNum"> 1306</span> : </span>
<span id="L1307"><span class="lineNum"> 1307</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT</span>
<span id="L1308"><span class="lineNum"> 1308</span> : template&lt;typename _Tp, typename _Up&gt;</span>
<span id="L1309"><span class="lineNum"> 1309</span> : constexpr typename</span>
<span id="L1310"><span class="lineNum"> 1310</span> : __gnu_cxx::__enable_if&lt;(__is_arithmetic&lt;_Tp&gt;::__value</span>
<span id="L1311"><span class="lineNum"> 1311</span> : &amp;&amp; __is_arithmetic&lt;_Up&gt;::__value), bool&gt;::__type</span>
<span id="L1312"><span class="lineNum"> 1312</span> : isless(_Tp __x, _Up __y)</span>
<span id="L1313"><span class="lineNum"> 1313</span> : {</span>
<span id="L1314"><span class="lineNum"> 1314</span> : typedef typename __gnu_cxx::__promote_2&lt;_Tp, _Up&gt;::__type __type;</span>
<span id="L1315"><span class="lineNum"> 1315</span> : return __builtin_isless(__type(__x), __type(__y));</span>
<span id="L1316"><span class="lineNum"> 1316</span> : }</span>
<span id="L1317"><span class="lineNum"> 1317</span> : #endif</span>
<span id="L1318"><span class="lineNum"> 1318</span> : </span>
<span id="L1319"><span class="lineNum"> 1319</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP</span>
<span id="L1320"><span class="lineNum"> 1320</span> : constexpr bool</span>
<span id="L1321"><span class="lineNum"> 1321</span> : islessequal(float __x, float __y)</span>
<span id="L1322"><span class="lineNum"> 1322</span> : { return __builtin_islessequal(__x, __y); }</span>
<span id="L1323"><span class="lineNum"> 1323</span> : </span>
<span id="L1324"><span class="lineNum"> 1324</span> : constexpr bool</span>
<span id="L1325"><span class="lineNum"> 1325</span> : islessequal(double __x, double __y)</span>
<span id="L1326"><span class="lineNum"> 1326</span> : { return __builtin_islessequal(__x, __y); }</span>
<span id="L1327"><span class="lineNum"> 1327</span> : </span>
<span id="L1328"><span class="lineNum"> 1328</span> : constexpr bool</span>
<span id="L1329"><span class="lineNum"> 1329</span> : islessequal(long double __x, long double __y)</span>
<span id="L1330"><span class="lineNum"> 1330</span> : { return __builtin_islessequal(__x, __y); }</span>
<span id="L1331"><span class="lineNum"> 1331</span> : #endif</span>
<span id="L1332"><span class="lineNum"> 1332</span> : </span>
<span id="L1333"><span class="lineNum"> 1333</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT</span>
<span id="L1334"><span class="lineNum"> 1334</span> : template&lt;typename _Tp, typename _Up&gt;</span>
<span id="L1335"><span class="lineNum"> 1335</span> : constexpr typename</span>
<span id="L1336"><span class="lineNum"> 1336</span> : __gnu_cxx::__enable_if&lt;(__is_arithmetic&lt;_Tp&gt;::__value</span>
<span id="L1337"><span class="lineNum"> 1337</span> : &amp;&amp; __is_arithmetic&lt;_Up&gt;::__value), bool&gt;::__type</span>
<span id="L1338"><span class="lineNum"> 1338</span> : islessequal(_Tp __x, _Up __y)</span>
<span id="L1339"><span class="lineNum"> 1339</span> : {</span>
<span id="L1340"><span class="lineNum"> 1340</span> : typedef typename __gnu_cxx::__promote_2&lt;_Tp, _Up&gt;::__type __type;</span>
<span id="L1341"><span class="lineNum"> 1341</span> : return __builtin_islessequal(__type(__x), __type(__y));</span>
<span id="L1342"><span class="lineNum"> 1342</span> : }</span>
<span id="L1343"><span class="lineNum"> 1343</span> : #endif</span>
<span id="L1344"><span class="lineNum"> 1344</span> : </span>
<span id="L1345"><span class="lineNum"> 1345</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP</span>
<span id="L1346"><span class="lineNum"> 1346</span> : constexpr bool</span>
<span id="L1347"><span class="lineNum"> 1347</span> : islessgreater(float __x, float __y)</span>
<span id="L1348"><span class="lineNum"> 1348</span> : { return __builtin_islessgreater(__x, __y); }</span>
<span id="L1349"><span class="lineNum"> 1349</span> : </span>
<span id="L1350"><span class="lineNum"> 1350</span> : constexpr bool</span>
<span id="L1351"><span class="lineNum"> 1351</span> : islessgreater(double __x, double __y)</span>
<span id="L1352"><span class="lineNum"> 1352</span> : { return __builtin_islessgreater(__x, __y); }</span>
<span id="L1353"><span class="lineNum"> 1353</span> : </span>
<span id="L1354"><span class="lineNum"> 1354</span> : constexpr bool</span>
<span id="L1355"><span class="lineNum"> 1355</span> : islessgreater(long double __x, long double __y)</span>
<span id="L1356"><span class="lineNum"> 1356</span> : { return __builtin_islessgreater(__x, __y); }</span>
<span id="L1357"><span class="lineNum"> 1357</span> : #endif</span>
<span id="L1358"><span class="lineNum"> 1358</span> : </span>
<span id="L1359"><span class="lineNum"> 1359</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT</span>
<span id="L1360"><span class="lineNum"> 1360</span> : template&lt;typename _Tp, typename _Up&gt;</span>
<span id="L1361"><span class="lineNum"> 1361</span> : constexpr typename</span>
<span id="L1362"><span class="lineNum"> 1362</span> : __gnu_cxx::__enable_if&lt;(__is_arithmetic&lt;_Tp&gt;::__value</span>
<span id="L1363"><span class="lineNum"> 1363</span> : &amp;&amp; __is_arithmetic&lt;_Up&gt;::__value), bool&gt;::__type</span>
<span id="L1364"><span class="lineNum"> 1364</span> : islessgreater(_Tp __x, _Up __y)</span>
<span id="L1365"><span class="lineNum"> 1365</span> : {</span>
<span id="L1366"><span class="lineNum"> 1366</span> : typedef typename __gnu_cxx::__promote_2&lt;_Tp, _Up&gt;::__type __type;</span>
<span id="L1367"><span class="lineNum"> 1367</span> : return __builtin_islessgreater(__type(__x), __type(__y));</span>
<span id="L1368"><span class="lineNum"> 1368</span> : }</span>
<span id="L1369"><span class="lineNum"> 1369</span> : #endif</span>
<span id="L1370"><span class="lineNum"> 1370</span> : </span>
<span id="L1371"><span class="lineNum"> 1371</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP</span>
<span id="L1372"><span class="lineNum"> 1372</span> : constexpr bool</span>
<span id="L1373"><span class="lineNum"> 1373</span> : isunordered(float __x, float __y)</span>
<span id="L1374"><span class="lineNum"> 1374</span> : { return __builtin_isunordered(__x, __y); }</span>
<span id="L1375"><span class="lineNum"> 1375</span> : </span>
<span id="L1376"><span class="lineNum"> 1376</span> : constexpr bool</span>
<span id="L1377"><span class="lineNum"> 1377</span> : isunordered(double __x, double __y)</span>
<span id="L1378"><span class="lineNum"> 1378</span> : { return __builtin_isunordered(__x, __y); }</span>
<span id="L1379"><span class="lineNum"> 1379</span> : </span>
<span id="L1380"><span class="lineNum"> 1380</span> : constexpr bool</span>
<span id="L1381"><span class="lineNum"> 1381</span> : isunordered(long double __x, long double __y)</span>
<span id="L1382"><span class="lineNum"> 1382</span> : { return __builtin_isunordered(__x, __y); }</span>
<span id="L1383"><span class="lineNum"> 1383</span> : #endif</span>
<span id="L1384"><span class="lineNum"> 1384</span> : </span>
<span id="L1385"><span class="lineNum"> 1385</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT</span>
<span id="L1386"><span class="lineNum"> 1386</span> : template&lt;typename _Tp, typename _Up&gt;</span>
<span id="L1387"><span class="lineNum"> 1387</span> : constexpr typename</span>
<span id="L1388"><span class="lineNum"> 1388</span> : __gnu_cxx::__enable_if&lt;(__is_arithmetic&lt;_Tp&gt;::__value</span>
<span id="L1389"><span class="lineNum"> 1389</span> : &amp;&amp; __is_arithmetic&lt;_Up&gt;::__value), bool&gt;::__type</span>
<span id="L1390"><span class="lineNum"> 1390</span> : isunordered(_Tp __x, _Up __y)</span>
<span id="L1391"><span class="lineNum"> 1391</span> : {</span>
<span id="L1392"><span class="lineNum"> 1392</span> : typedef typename __gnu_cxx::__promote_2&lt;_Tp, _Up&gt;::__type __type;</span>
<span id="L1393"><span class="lineNum"> 1393</span> : return __builtin_isunordered(__type(__x), __type(__y));</span>
<span id="L1394"><span class="lineNum"> 1394</span> : }</span>
<span id="L1395"><span class="lineNum"> 1395</span> : #endif</span>
<span id="L1396"><span class="lineNum"> 1396</span> : </span>
<span id="L1397"><span class="lineNum"> 1397</span> : #else</span>
<span id="L1398"><span class="lineNum"> 1398</span> : </span>
<span id="L1399"><span class="lineNum"> 1399</span> : template&lt;typename _Tp&gt;</span>
<span id="L1400"><span class="lineNum"> 1400</span> : inline typename __gnu_cxx::__enable_if&lt;__is_arithmetic&lt;_Tp&gt;::__value,</span>
<span id="L1401"><span class="lineNum"> 1401</span> : int&gt;::__type</span>
<span id="L1402"><span class="lineNum"> 1402</span> : fpclassify(_Tp __f)</span>
<span id="L1403"><span class="lineNum"> 1403</span> : {</span>
<span id="L1404"><span class="lineNum"> 1404</span> : typedef typename __gnu_cxx::__promote&lt;_Tp&gt;::__type __type;</span>
<span id="L1405"><span class="lineNum"> 1405</span> : return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,</span>
<span id="L1406"><span class="lineNum"> 1406</span> : FP_SUBNORMAL, FP_ZERO, __type(__f));</span>
<span id="L1407"><span class="lineNum"> 1407</span> : }</span>
<span id="L1408"><span class="lineNum"> 1408</span> : </span>
<span id="L1409"><span class="lineNum"> 1409</span> : template&lt;typename _Tp&gt;</span>
<span id="L1410"><span class="lineNum"> 1410</span> : inline typename __gnu_cxx::__enable_if&lt;__is_arithmetic&lt;_Tp&gt;::__value,</span>
<span id="L1411"><span class="lineNum"> 1411</span> : int&gt;::__type</span>
<span id="L1412"><span class="lineNum"> 1412</span> : isfinite(_Tp __f)</span>
<span id="L1413"><span class="lineNum"> 1413</span> : {</span>
<span id="L1414"><span class="lineNum"> 1414</span> : typedef typename __gnu_cxx::__promote&lt;_Tp&gt;::__type __type;</span>
<span id="L1415"><span class="lineNum"> 1415</span> : return __builtin_isfinite(__type(__f));</span>
<span id="L1416"><span class="lineNum"> 1416</span> : }</span>
<span id="L1417"><span class="lineNum"> 1417</span> : </span>
<span id="L1418"><span class="lineNum"> 1418</span> : template&lt;typename _Tp&gt;</span>
<span id="L1419"><span class="lineNum"> 1419</span> : inline typename __gnu_cxx::__enable_if&lt;__is_arithmetic&lt;_Tp&gt;::__value,</span>
<span id="L1420"><span class="lineNum"> 1420</span> : int&gt;::__type</span>
<span id="L1421"><span class="lineNum"> 1421</span> : isinf(_Tp __f)</span>
<span id="L1422"><span class="lineNum"> 1422</span> : {</span>
<span id="L1423"><span class="lineNum"> 1423</span> : typedef typename __gnu_cxx::__promote&lt;_Tp&gt;::__type __type;</span>
<span id="L1424"><span class="lineNum"> 1424</span> : return __builtin_isinf(__type(__f));</span>
<span id="L1425"><span class="lineNum"> 1425</span> : }</span>
<span id="L1426"><span class="lineNum"> 1426</span> : </span>
<span id="L1427"><span class="lineNum"> 1427</span> : template&lt;typename _Tp&gt;</span>
<span id="L1428"><span class="lineNum"> 1428</span> : inline typename __gnu_cxx::__enable_if&lt;__is_arithmetic&lt;_Tp&gt;::__value,</span>
<span id="L1429"><span class="lineNum"> 1429</span> : int&gt;::__type</span>
<span id="L1430"><span class="lineNum"> 1430</span> : isnan(_Tp __f)</span>
<span id="L1431"><span class="lineNum"> 1431</span> : {</span>
<span id="L1432"><span class="lineNum"> 1432</span> : typedef typename __gnu_cxx::__promote&lt;_Tp&gt;::__type __type;</span>
<span id="L1433"><span class="lineNum"> 1433</span> : return __builtin_isnan(__type(__f));</span>
<span id="L1434"><span class="lineNum"> 1434</span> : }</span>
<span id="L1435"><span class="lineNum"> 1435</span> : </span>
<span id="L1436"><span class="lineNum"> 1436</span> : template&lt;typename _Tp&gt;</span>
<span id="L1437"><span class="lineNum"> 1437</span> : inline typename __gnu_cxx::__enable_if&lt;__is_arithmetic&lt;_Tp&gt;::__value,</span>
<span id="L1438"><span class="lineNum"> 1438</span> : int&gt;::__type</span>
<span id="L1439"><span class="lineNum"> 1439</span> : isnormal(_Tp __f)</span>
<span id="L1440"><span class="lineNum"> 1440</span> : {</span>
<span id="L1441"><span class="lineNum"> 1441</span> : typedef typename __gnu_cxx::__promote&lt;_Tp&gt;::__type __type;</span>
<span id="L1442"><span class="lineNum"> 1442</span> : return __builtin_isnormal(__type(__f));</span>
<span id="L1443"><span class="lineNum"> 1443</span> : }</span>
<span id="L1444"><span class="lineNum"> 1444</span> : </span>
<span id="L1445"><span class="lineNum"> 1445</span> : template&lt;typename _Tp&gt;</span>
<span id="L1446"><span class="lineNum"> 1446</span> : inline typename __gnu_cxx::__enable_if&lt;__is_arithmetic&lt;_Tp&gt;::__value,</span>
<span id="L1447"><span class="lineNum"> 1447</span> : int&gt;::__type</span>
<span id="L1448"><span class="lineNum"> 1448</span> : signbit(_Tp __f)</span>
<span id="L1449"><span class="lineNum"> 1449</span> : {</span>
<span id="L1450"><span class="lineNum"> 1450</span> : typedef typename __gnu_cxx::__promote&lt;_Tp&gt;::__type __type;</span>
<span id="L1451"><span class="lineNum"> 1451</span> : return __builtin_signbit(__type(__f));</span>
<span id="L1452"><span class="lineNum"> 1452</span> : }</span>
<span id="L1453"><span class="lineNum"> 1453</span> : </span>
<span id="L1454"><span class="lineNum"> 1454</span> : template&lt;typename _Tp&gt;</span>
<span id="L1455"><span class="lineNum"> 1455</span> : inline typename __gnu_cxx::__enable_if&lt;__is_arithmetic&lt;_Tp&gt;::__value,</span>
<span id="L1456"><span class="lineNum"> 1456</span> : int&gt;::__type</span>
<span id="L1457"><span class="lineNum"> 1457</span> : isgreater(_Tp __f1, _Tp __f2)</span>
<span id="L1458"><span class="lineNum"> 1458</span> : {</span>
<span id="L1459"><span class="lineNum"> 1459</span> : typedef typename __gnu_cxx::__promote&lt;_Tp&gt;::__type __type;</span>
<span id="L1460"><span class="lineNum"> 1460</span> : return __builtin_isgreater(__type(__f1), __type(__f2));</span>
<span id="L1461"><span class="lineNum"> 1461</span> : }</span>
<span id="L1462"><span class="lineNum"> 1462</span> : </span>
<span id="L1463"><span class="lineNum"> 1463</span> : template&lt;typename _Tp&gt;</span>
<span id="L1464"><span class="lineNum"> 1464</span> : inline typename __gnu_cxx::__enable_if&lt;__is_arithmetic&lt;_Tp&gt;::__value,</span>
<span id="L1465"><span class="lineNum"> 1465</span> : int&gt;::__type</span>
<span id="L1466"><span class="lineNum"> 1466</span> : isgreaterequal(_Tp __f1, _Tp __f2)</span>
<span id="L1467"><span class="lineNum"> 1467</span> : {</span>
<span id="L1468"><span class="lineNum"> 1468</span> : typedef typename __gnu_cxx::__promote&lt;_Tp&gt;::__type __type;</span>
<span id="L1469"><span class="lineNum"> 1469</span> : return __builtin_isgreaterequal(__type(__f1), __type(__f2));</span>
<span id="L1470"><span class="lineNum"> 1470</span> : }</span>
<span id="L1471"><span class="lineNum"> 1471</span> : </span>
<span id="L1472"><span class="lineNum"> 1472</span> : template&lt;typename _Tp&gt;</span>
<span id="L1473"><span class="lineNum"> 1473</span> : inline typename __gnu_cxx::__enable_if&lt;__is_arithmetic&lt;_Tp&gt;::__value,</span>
<span id="L1474"><span class="lineNum"> 1474</span> : int&gt;::__type</span>
<span id="L1475"><span class="lineNum"> 1475</span> : isless(_Tp __f1, _Tp __f2)</span>
<span id="L1476"><span class="lineNum"> 1476</span> : {</span>
<span id="L1477"><span class="lineNum"> 1477</span> : typedef typename __gnu_cxx::__promote&lt;_Tp&gt;::__type __type;</span>
<span id="L1478"><span class="lineNum"> 1478</span> : return __builtin_isless(__type(__f1), __type(__f2));</span>
<span id="L1479"><span class="lineNum"> 1479</span> : }</span>
<span id="L1480"><span class="lineNum"> 1480</span> : </span>
<span id="L1481"><span class="lineNum"> 1481</span> : template&lt;typename _Tp&gt;</span>
<span id="L1482"><span class="lineNum"> 1482</span> : inline typename __gnu_cxx::__enable_if&lt;__is_arithmetic&lt;_Tp&gt;::__value,</span>
<span id="L1483"><span class="lineNum"> 1483</span> : int&gt;::__type</span>
<span id="L1484"><span class="lineNum"> 1484</span> : islessequal(_Tp __f1, _Tp __f2)</span>
<span id="L1485"><span class="lineNum"> 1485</span> : {</span>
<span id="L1486"><span class="lineNum"> 1486</span> : typedef typename __gnu_cxx::__promote&lt;_Tp&gt;::__type __type;</span>
<span id="L1487"><span class="lineNum"> 1487</span> : return __builtin_islessequal(__type(__f1), __type(__f2));</span>
<span id="L1488"><span class="lineNum"> 1488</span> : }</span>
<span id="L1489"><span class="lineNum"> 1489</span> : </span>
<span id="L1490"><span class="lineNum"> 1490</span> : template&lt;typename _Tp&gt;</span>
<span id="L1491"><span class="lineNum"> 1491</span> : inline typename __gnu_cxx::__enable_if&lt;__is_arithmetic&lt;_Tp&gt;::__value,</span>
<span id="L1492"><span class="lineNum"> 1492</span> : int&gt;::__type</span>
<span id="L1493"><span class="lineNum"> 1493</span> : islessgreater(_Tp __f1, _Tp __f2)</span>
<span id="L1494"><span class="lineNum"> 1494</span> : {</span>
<span id="L1495"><span class="lineNum"> 1495</span> : typedef typename __gnu_cxx::__promote&lt;_Tp&gt;::__type __type;</span>
<span id="L1496"><span class="lineNum"> 1496</span> : return __builtin_islessgreater(__type(__f1), __type(__f2));</span>
<span id="L1497"><span class="lineNum"> 1497</span> : }</span>
<span id="L1498"><span class="lineNum"> 1498</span> : </span>
<span id="L1499"><span class="lineNum"> 1499</span> : template&lt;typename _Tp&gt;</span>
<span id="L1500"><span class="lineNum"> 1500</span> : inline typename __gnu_cxx::__enable_if&lt;__is_arithmetic&lt;_Tp&gt;::__value,</span>
<span id="L1501"><span class="lineNum"> 1501</span> : int&gt;::__type</span>
<span id="L1502"><span class="lineNum"> 1502</span> : isunordered(_Tp __f1, _Tp __f2)</span>
<span id="L1503"><span class="lineNum"> 1503</span> : {</span>
<span id="L1504"><span class="lineNum"> 1504</span> : typedef typename __gnu_cxx::__promote&lt;_Tp&gt;::__type __type;</span>
<span id="L1505"><span class="lineNum"> 1505</span> : return __builtin_isunordered(__type(__f1), __type(__f2));</span>
<span id="L1506"><span class="lineNum"> 1506</span> : }</span>
<span id="L1507"><span class="lineNum"> 1507</span> : </span>
<span id="L1508"><span class="lineNum"> 1508</span> : #endif // C++11</span>
<span id="L1509"><span class="lineNum"> 1509</span> : </span>
<span id="L1510"><span class="lineNum"> 1510</span> : #ifdef __STDCPP_FLOAT16_T__</span>
<span id="L1511"><span class="lineNum"> 1511</span> : constexpr int</span>
<span id="L1512"><span class="lineNum"> 1512</span> : fpclassify(_Float16 __x)</span>
<span id="L1513"><span class="lineNum"> 1513</span> : { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,</span>
<span id="L1514"><span class="lineNum"> 1514</span> : FP_SUBNORMAL, FP_ZERO, __x); }</span>
<span id="L1515"><span class="lineNum"> 1515</span> : </span>
<span id="L1516"><span class="lineNum"> 1516</span> : constexpr bool</span>
<span id="L1517"><span class="lineNum"> 1517</span> : isfinite(_Float16 __x)</span>
<span id="L1518"><span class="lineNum"> 1518</span> : { return __builtin_isfinite(__x); }</span>
<span id="L1519"><span class="lineNum"> 1519</span> : </span>
<span id="L1520"><span class="lineNum"> 1520</span> : constexpr bool</span>
<span id="L1521"><span class="lineNum"> 1521</span> : isinf(_Float16 __x)</span>
<span id="L1522"><span class="lineNum"> 1522</span> : { return __builtin_isinf(__x); }</span>
<span id="L1523"><span class="lineNum"> 1523</span> : </span>
<span id="L1524"><span class="lineNum"> 1524</span> : constexpr bool</span>
<span id="L1525"><span class="lineNum"> 1525</span> : isnan(_Float16 __x)</span>
<span id="L1526"><span class="lineNum"> 1526</span> : { return __builtin_isnan(__x); }</span>
<span id="L1527"><span class="lineNum"> 1527</span> : </span>
<span id="L1528"><span class="lineNum"> 1528</span> : constexpr bool</span>
<span id="L1529"><span class="lineNum"> 1529</span> : isnormal(_Float16 __x)</span>
<span id="L1530"><span class="lineNum"> 1530</span> : { return __builtin_isnormal(__x); }</span>
<span id="L1531"><span class="lineNum"> 1531</span> : </span>
<span id="L1532"><span class="lineNum"> 1532</span> : constexpr bool</span>
<span id="L1533"><span class="lineNum"> 1533</span> : signbit(_Float16 __x)</span>
<span id="L1534"><span class="lineNum"> 1534</span> : { return __builtin_signbit(__x); }</span>
<span id="L1535"><span class="lineNum"> 1535</span> : </span>
<span id="L1536"><span class="lineNum"> 1536</span> : constexpr bool</span>
<span id="L1537"><span class="lineNum"> 1537</span> : isgreater(_Float16 __x, _Float16 __y)</span>
<span id="L1538"><span class="lineNum"> 1538</span> : { return __builtin_isgreater(__x, __y); }</span>
<span id="L1539"><span class="lineNum"> 1539</span> : </span>
<span id="L1540"><span class="lineNum"> 1540</span> : constexpr bool</span>
<span id="L1541"><span class="lineNum"> 1541</span> : isgreaterequal(_Float16 __x, _Float16 __y)</span>
<span id="L1542"><span class="lineNum"> 1542</span> : { return __builtin_isgreaterequal(__x, __y); }</span>
<span id="L1543"><span class="lineNum"> 1543</span> : </span>
<span id="L1544"><span class="lineNum"> 1544</span> : constexpr bool</span>
<span id="L1545"><span class="lineNum"> 1545</span> : isless(_Float16 __x, _Float16 __y)</span>
<span id="L1546"><span class="lineNum"> 1546</span> : { return __builtin_isless(__x, __y); }</span>
<span id="L1547"><span class="lineNum"> 1547</span> : </span>
<span id="L1548"><span class="lineNum"> 1548</span> : constexpr bool</span>
<span id="L1549"><span class="lineNum"> 1549</span> : islessequal(_Float16 __x, _Float16 __y)</span>
<span id="L1550"><span class="lineNum"> 1550</span> : { return __builtin_islessequal(__x, __y); }</span>
<span id="L1551"><span class="lineNum"> 1551</span> : </span>
<span id="L1552"><span class="lineNum"> 1552</span> : constexpr bool</span>
<span id="L1553"><span class="lineNum"> 1553</span> : islessgreater(_Float16 __x, _Float16 __y)</span>
<span id="L1554"><span class="lineNum"> 1554</span> : { return __builtin_islessgreater(__x, __y); }</span>
<span id="L1555"><span class="lineNum"> 1555</span> : </span>
<span id="L1556"><span class="lineNum"> 1556</span> : constexpr bool</span>
<span id="L1557"><span class="lineNum"> 1557</span> : isunordered(_Float16 __x, _Float16 __y)</span>
<span id="L1558"><span class="lineNum"> 1558</span> : { return __builtin_isunordered(__x, __y); }</span>
<span id="L1559"><span class="lineNum"> 1559</span> : #endif</span>
<span id="L1560"><span class="lineNum"> 1560</span> : </span>
<span id="L1561"><span class="lineNum"> 1561</span> : #ifdef __STDCPP_FLOAT32_T__</span>
<span id="L1562"><span class="lineNum"> 1562</span> : constexpr int</span>
<span id="L1563"><span class="lineNum"> 1563</span> : fpclassify(_Float32 __x)</span>
<span id="L1564"><span class="lineNum"> 1564</span> : { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,</span>
<span id="L1565"><span class="lineNum"> 1565</span> : FP_SUBNORMAL, FP_ZERO, __x); }</span>
<span id="L1566"><span class="lineNum"> 1566</span> : </span>
<span id="L1567"><span class="lineNum"> 1567</span> : constexpr bool</span>
<span id="L1568"><span class="lineNum"> 1568</span> : isfinite(_Float32 __x)</span>
<span id="L1569"><span class="lineNum"> 1569</span> : { return __builtin_isfinite(__x); }</span>
<span id="L1570"><span class="lineNum"> 1570</span> : </span>
<span id="L1571"><span class="lineNum"> 1571</span> : constexpr bool</span>
<span id="L1572"><span class="lineNum"> 1572</span> : isinf(_Float32 __x)</span>
<span id="L1573"><span class="lineNum"> 1573</span> : { return __builtin_isinf(__x); }</span>
<span id="L1574"><span class="lineNum"> 1574</span> : </span>
<span id="L1575"><span class="lineNum"> 1575</span> : constexpr bool</span>
<span id="L1576"><span class="lineNum"> 1576</span> : isnan(_Float32 __x)</span>
<span id="L1577"><span class="lineNum"> 1577</span> : { return __builtin_isnan(__x); }</span>
<span id="L1578"><span class="lineNum"> 1578</span> : </span>
<span id="L1579"><span class="lineNum"> 1579</span> : constexpr bool</span>
<span id="L1580"><span class="lineNum"> 1580</span> : isnormal(_Float32 __x)</span>
<span id="L1581"><span class="lineNum"> 1581</span> : { return __builtin_isnormal(__x); }</span>
<span id="L1582"><span class="lineNum"> 1582</span> : </span>
<span id="L1583"><span class="lineNum"> 1583</span> : constexpr bool</span>
<span id="L1584"><span class="lineNum"> 1584</span> : signbit(_Float32 __x)</span>
<span id="L1585"><span class="lineNum"> 1585</span> : { return __builtin_signbit(__x); }</span>
<span id="L1586"><span class="lineNum"> 1586</span> : </span>
<span id="L1587"><span class="lineNum"> 1587</span> : constexpr bool</span>
<span id="L1588"><span class="lineNum"> 1588</span> : isgreater(_Float32 __x, _Float32 __y)</span>
<span id="L1589"><span class="lineNum"> 1589</span> : { return __builtin_isgreater(__x, __y); }</span>
<span id="L1590"><span class="lineNum"> 1590</span> : </span>
<span id="L1591"><span class="lineNum"> 1591</span> : constexpr bool</span>
<span id="L1592"><span class="lineNum"> 1592</span> : isgreaterequal(_Float32 __x, _Float32 __y)</span>
<span id="L1593"><span class="lineNum"> 1593</span> : { return __builtin_isgreaterequal(__x, __y); }</span>
<span id="L1594"><span class="lineNum"> 1594</span> : </span>
<span id="L1595"><span class="lineNum"> 1595</span> : constexpr bool</span>
<span id="L1596"><span class="lineNum"> 1596</span> : isless(_Float32 __x, _Float32 __y)</span>
<span id="L1597"><span class="lineNum"> 1597</span> : { return __builtin_isless(__x, __y); }</span>
<span id="L1598"><span class="lineNum"> 1598</span> : </span>
<span id="L1599"><span class="lineNum"> 1599</span> : constexpr bool</span>
<span id="L1600"><span class="lineNum"> 1600</span> : islessequal(_Float32 __x, _Float32 __y)</span>
<span id="L1601"><span class="lineNum"> 1601</span> : { return __builtin_islessequal(__x, __y); }</span>
<span id="L1602"><span class="lineNum"> 1602</span> : </span>
<span id="L1603"><span class="lineNum"> 1603</span> : constexpr bool</span>
<span id="L1604"><span class="lineNum"> 1604</span> : islessgreater(_Float32 __x, _Float32 __y)</span>
<span id="L1605"><span class="lineNum"> 1605</span> : { return __builtin_islessgreater(__x, __y); }</span>
<span id="L1606"><span class="lineNum"> 1606</span> : </span>
<span id="L1607"><span class="lineNum"> 1607</span> : constexpr bool</span>
<span id="L1608"><span class="lineNum"> 1608</span> : isunordered(_Float32 __x, _Float32 __y)</span>
<span id="L1609"><span class="lineNum"> 1609</span> : { return __builtin_isunordered(__x, __y); }</span>
<span id="L1610"><span class="lineNum"> 1610</span> : #endif</span>
<span id="L1611"><span class="lineNum"> 1611</span> : </span>
<span id="L1612"><span class="lineNum"> 1612</span> : #ifdef __STDCPP_FLOAT64_T__</span>
<span id="L1613"><span class="lineNum"> 1613</span> : constexpr int</span>
<span id="L1614"><span class="lineNum"> 1614</span> : fpclassify(_Float64 __x)</span>
<span id="L1615"><span class="lineNum"> 1615</span> : { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,</span>
<span id="L1616"><span class="lineNum"> 1616</span> : FP_SUBNORMAL, FP_ZERO, __x); }</span>
<span id="L1617"><span class="lineNum"> 1617</span> : </span>
<span id="L1618"><span class="lineNum"> 1618</span> : constexpr bool</span>
<span id="L1619"><span class="lineNum"> 1619</span> : isfinite(_Float64 __x)</span>
<span id="L1620"><span class="lineNum"> 1620</span> : { return __builtin_isfinite(__x); }</span>
<span id="L1621"><span class="lineNum"> 1621</span> : </span>
<span id="L1622"><span class="lineNum"> 1622</span> : constexpr bool</span>
<span id="L1623"><span class="lineNum"> 1623</span> : isinf(_Float64 __x)</span>
<span id="L1624"><span class="lineNum"> 1624</span> : { return __builtin_isinf(__x); }</span>
<span id="L1625"><span class="lineNum"> 1625</span> : </span>
<span id="L1626"><span class="lineNum"> 1626</span> : constexpr bool</span>
<span id="L1627"><span class="lineNum"> 1627</span> : isnan(_Float64 __x)</span>
<span id="L1628"><span class="lineNum"> 1628</span> : { return __builtin_isnan(__x); }</span>
<span id="L1629"><span class="lineNum"> 1629</span> : </span>
<span id="L1630"><span class="lineNum"> 1630</span> : constexpr bool</span>
<span id="L1631"><span class="lineNum"> 1631</span> : isnormal(_Float64 __x)</span>
<span id="L1632"><span class="lineNum"> 1632</span> : { return __builtin_isnormal(__x); }</span>
<span id="L1633"><span class="lineNum"> 1633</span> : </span>
<span id="L1634"><span class="lineNum"> 1634</span> : constexpr bool</span>
<span id="L1635"><span class="lineNum"> 1635</span> : signbit(_Float64 __x)</span>
<span id="L1636"><span class="lineNum"> 1636</span> : { return __builtin_signbit(__x); }</span>
<span id="L1637"><span class="lineNum"> 1637</span> : </span>
<span id="L1638"><span class="lineNum"> 1638</span> : constexpr bool</span>
<span id="L1639"><span class="lineNum"> 1639</span> : isgreater(_Float64 __x, _Float64 __y)</span>
<span id="L1640"><span class="lineNum"> 1640</span> : { return __builtin_isgreater(__x, __y); }</span>
<span id="L1641"><span class="lineNum"> 1641</span> : </span>
<span id="L1642"><span class="lineNum"> 1642</span> : constexpr bool</span>
<span id="L1643"><span class="lineNum"> 1643</span> : isgreaterequal(_Float64 __x, _Float64 __y)</span>
<span id="L1644"><span class="lineNum"> 1644</span> : { return __builtin_isgreaterequal(__x, __y); }</span>
<span id="L1645"><span class="lineNum"> 1645</span> : </span>
<span id="L1646"><span class="lineNum"> 1646</span> : constexpr bool</span>
<span id="L1647"><span class="lineNum"> 1647</span> : isless(_Float64 __x, _Float64 __y)</span>
<span id="L1648"><span class="lineNum"> 1648</span> : { return __builtin_isless(__x, __y); }</span>
<span id="L1649"><span class="lineNum"> 1649</span> : </span>
<span id="L1650"><span class="lineNum"> 1650</span> : constexpr bool</span>
<span id="L1651"><span class="lineNum"> 1651</span> : islessequal(_Float64 __x, _Float64 __y)</span>
<span id="L1652"><span class="lineNum"> 1652</span> : { return __builtin_islessequal(__x, __y); }</span>
<span id="L1653"><span class="lineNum"> 1653</span> : </span>
<span id="L1654"><span class="lineNum"> 1654</span> : constexpr bool</span>
<span id="L1655"><span class="lineNum"> 1655</span> : islessgreater(_Float64 __x, _Float64 __y)</span>
<span id="L1656"><span class="lineNum"> 1656</span> : { return __builtin_islessgreater(__x, __y); }</span>
<span id="L1657"><span class="lineNum"> 1657</span> : </span>
<span id="L1658"><span class="lineNum"> 1658</span> : constexpr bool</span>
<span id="L1659"><span class="lineNum"> 1659</span> : isunordered(_Float64 __x, _Float64 __y)</span>
<span id="L1660"><span class="lineNum"> 1660</span> : { return __builtin_isunordered(__x, __y); }</span>
<span id="L1661"><span class="lineNum"> 1661</span> : #endif</span>
<span id="L1662"><span class="lineNum"> 1662</span> : </span>
<span id="L1663"><span class="lineNum"> 1663</span> : #ifdef __STDCPP_FLOAT128_T__</span>
<span id="L1664"><span class="lineNum"> 1664</span> : constexpr int</span>
<span id="L1665"><span class="lineNum"> 1665</span> : fpclassify(_Float128 __x)</span>
<span id="L1666"><span class="lineNum"> 1666</span> : { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,</span>
<span id="L1667"><span class="lineNum"> 1667</span> : FP_SUBNORMAL, FP_ZERO, __x); }</span>
<span id="L1668"><span class="lineNum"> 1668</span> : </span>
<span id="L1669"><span class="lineNum"> 1669</span> : constexpr bool</span>
<span id="L1670"><span class="lineNum"> 1670</span> : isfinite(_Float128 __x)</span>
<span id="L1671"><span class="lineNum"> 1671</span> : { return __builtin_isfinite(__x); }</span>
<span id="L1672"><span class="lineNum"> 1672</span> : </span>
<span id="L1673"><span class="lineNum"> 1673</span> : constexpr bool</span>
<span id="L1674"><span class="lineNum"> 1674</span> : isinf(_Float128 __x)</span>
<span id="L1675"><span class="lineNum"> 1675</span> : { return __builtin_isinf(__x); }</span>
<span id="L1676"><span class="lineNum"> 1676</span> : </span>
<span id="L1677"><span class="lineNum"> 1677</span> : constexpr bool</span>
<span id="L1678"><span class="lineNum"> 1678</span> : isnan(_Float128 __x)</span>
<span id="L1679"><span class="lineNum"> 1679</span> : { return __builtin_isnan(__x); }</span>
<span id="L1680"><span class="lineNum"> 1680</span> : </span>
<span id="L1681"><span class="lineNum"> 1681</span> : constexpr bool</span>
<span id="L1682"><span class="lineNum"> 1682</span> : isnormal(_Float128 __x)</span>
<span id="L1683"><span class="lineNum"> 1683</span> : { return __builtin_isnormal(__x); }</span>
<span id="L1684"><span class="lineNum"> 1684</span> : </span>
<span id="L1685"><span class="lineNum"> 1685</span> : constexpr bool</span>
<span id="L1686"><span class="lineNum"> 1686</span> : signbit(_Float128 __x)</span>
<span id="L1687"><span class="lineNum"> 1687</span> : { return __builtin_signbit(__x); }</span>
<span id="L1688"><span class="lineNum"> 1688</span> : </span>
<span id="L1689"><span class="lineNum"> 1689</span> : constexpr bool</span>
<span id="L1690"><span class="lineNum"> 1690</span> : isgreater(_Float128 __x, _Float128 __y)</span>
<span id="L1691"><span class="lineNum"> 1691</span> : { return __builtin_isgreater(__x, __y); }</span>
<span id="L1692"><span class="lineNum"> 1692</span> : </span>
<span id="L1693"><span class="lineNum"> 1693</span> : constexpr bool</span>
<span id="L1694"><span class="lineNum"> 1694</span> : isgreaterequal(_Float128 __x, _Float128 __y)</span>
<span id="L1695"><span class="lineNum"> 1695</span> : { return __builtin_isgreaterequal(__x, __y); }</span>
<span id="L1696"><span class="lineNum"> 1696</span> : </span>
<span id="L1697"><span class="lineNum"> 1697</span> : constexpr bool</span>
<span id="L1698"><span class="lineNum"> 1698</span> : isless(_Float128 __x, _Float128 __y)</span>
<span id="L1699"><span class="lineNum"> 1699</span> : { return __builtin_isless(__x, __y); }</span>
<span id="L1700"><span class="lineNum"> 1700</span> : </span>
<span id="L1701"><span class="lineNum"> 1701</span> : constexpr bool</span>
<span id="L1702"><span class="lineNum"> 1702</span> : islessequal(_Float128 __x, _Float128 __y)</span>
<span id="L1703"><span class="lineNum"> 1703</span> : { return __builtin_islessequal(__x, __y); }</span>
<span id="L1704"><span class="lineNum"> 1704</span> : </span>
<span id="L1705"><span class="lineNum"> 1705</span> : constexpr bool</span>
<span id="L1706"><span class="lineNum"> 1706</span> : islessgreater(_Float128 __x, _Float128 __y)</span>
<span id="L1707"><span class="lineNum"> 1707</span> : { return __builtin_islessgreater(__x, __y); }</span>
<span id="L1708"><span class="lineNum"> 1708</span> : </span>
<span id="L1709"><span class="lineNum"> 1709</span> : constexpr bool</span>
<span id="L1710"><span class="lineNum"> 1710</span> : isunordered(_Float128 __x, _Float128 __y)</span>
<span id="L1711"><span class="lineNum"> 1711</span> : { return __builtin_isunordered(__x, __y); }</span>
<span id="L1712"><span class="lineNum"> 1712</span> : #endif</span>
<span id="L1713"><span class="lineNum"> 1713</span> : </span>
<span id="L1714"><span class="lineNum"> 1714</span> : #ifdef __STDCPP_BFLOAT16_T__</span>
<span id="L1715"><span class="lineNum"> 1715</span> : constexpr int</span>
<span id="L1716"><span class="lineNum"> 1716</span> : fpclassify(__gnu_cxx::__bfloat16_t __x)</span>
<span id="L1717"><span class="lineNum"> 1717</span> : { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,</span>
<span id="L1718"><span class="lineNum"> 1718</span> : FP_SUBNORMAL, FP_ZERO, __x); }</span>
<span id="L1719"><span class="lineNum"> 1719</span> : </span>
<span id="L1720"><span class="lineNum"> 1720</span> : constexpr bool</span>
<span id="L1721"><span class="lineNum"> 1721</span> : isfinite(__gnu_cxx::__bfloat16_t __x)</span>
<span id="L1722"><span class="lineNum"> 1722</span> : { return __builtin_isfinite(__x); }</span>
<span id="L1723"><span class="lineNum"> 1723</span> : </span>
<span id="L1724"><span class="lineNum"> 1724</span> : constexpr bool</span>
<span id="L1725"><span class="lineNum"> 1725</span> : isinf(__gnu_cxx::__bfloat16_t __x)</span>
<span id="L1726"><span class="lineNum"> 1726</span> : { return __builtin_isinf(__x); }</span>
<span id="L1727"><span class="lineNum"> 1727</span> : </span>
<span id="L1728"><span class="lineNum"> 1728</span> : constexpr bool</span>
<span id="L1729"><span class="lineNum"> 1729</span> : isnan(__gnu_cxx::__bfloat16_t __x)</span>
<span id="L1730"><span class="lineNum"> 1730</span> : { return __builtin_isnan(__x); }</span>
<span id="L1731"><span class="lineNum"> 1731</span> : </span>
<span id="L1732"><span class="lineNum"> 1732</span> : constexpr bool</span>
<span id="L1733"><span class="lineNum"> 1733</span> : isnormal(__gnu_cxx::__bfloat16_t __x)</span>
<span id="L1734"><span class="lineNum"> 1734</span> : { return __builtin_isnormal(__x); }</span>
<span id="L1735"><span class="lineNum"> 1735</span> : </span>
<span id="L1736"><span class="lineNum"> 1736</span> : constexpr bool</span>
<span id="L1737"><span class="lineNum"> 1737</span> : signbit(__gnu_cxx::__bfloat16_t __x)</span>
<span id="L1738"><span class="lineNum"> 1738</span> : { return __builtin_signbit(__x); }</span>
<span id="L1739"><span class="lineNum"> 1739</span> : </span>
<span id="L1740"><span class="lineNum"> 1740</span> : constexpr bool</span>
<span id="L1741"><span class="lineNum"> 1741</span> : isgreater(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)</span>
<span id="L1742"><span class="lineNum"> 1742</span> : { return __builtin_isgreater(__x, __y); }</span>
<span id="L1743"><span class="lineNum"> 1743</span> : </span>
<span id="L1744"><span class="lineNum"> 1744</span> : constexpr bool</span>
<span id="L1745"><span class="lineNum"> 1745</span> : isgreaterequal(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)</span>
<span id="L1746"><span class="lineNum"> 1746</span> : { return __builtin_isgreaterequal(__x, __y); }</span>
<span id="L1747"><span class="lineNum"> 1747</span> : </span>
<span id="L1748"><span class="lineNum"> 1748</span> : constexpr bool</span>
<span id="L1749"><span class="lineNum"> 1749</span> : isless(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)</span>
<span id="L1750"><span class="lineNum"> 1750</span> : { return __builtin_isless(__x, __y); }</span>
<span id="L1751"><span class="lineNum"> 1751</span> : </span>
<span id="L1752"><span class="lineNum"> 1752</span> : constexpr bool</span>
<span id="L1753"><span class="lineNum"> 1753</span> : islessequal(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)</span>
<span id="L1754"><span class="lineNum"> 1754</span> : { return __builtin_islessequal(__x, __y); }</span>
<span id="L1755"><span class="lineNum"> 1755</span> : </span>
<span id="L1756"><span class="lineNum"> 1756</span> : constexpr bool</span>
<span id="L1757"><span class="lineNum"> 1757</span> : islessgreater(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)</span>
<span id="L1758"><span class="lineNum"> 1758</span> : { return __builtin_islessgreater(__x, __y); }</span>
<span id="L1759"><span class="lineNum"> 1759</span> : </span>
<span id="L1760"><span class="lineNum"> 1760</span> : constexpr bool</span>
<span id="L1761"><span class="lineNum"> 1761</span> : isunordered(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)</span>
<span id="L1762"><span class="lineNum"> 1762</span> : { return __builtin_isunordered(__x, __y); }</span>
<span id="L1763"><span class="lineNum"> 1763</span> : #endif</span>
<span id="L1764"><span class="lineNum"> 1764</span> : </span>
<span id="L1765"><span class="lineNum"> 1765</span> : #endif /* _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC */</span>
<span id="L1766"><span class="lineNum"> 1766</span> : #endif /* _GLIBCXX_USE_C99_MATH */</span>
<span id="L1767"><span class="lineNum"> 1767</span> : </span>
<span id="L1768"><span class="lineNum"> 1768</span> : #if __cplusplus &gt;= 201103L</span>
<span id="L1769"><span class="lineNum"> 1769</span> : </span>
<span id="L1770"><span class="lineNum"> 1770</span> : #ifdef _GLIBCXX_USE_C99_MATH_TR1</span>
<span id="L1771"><span class="lineNum"> 1771</span> : </span>
<span id="L1772"><span class="lineNum"> 1772</span> : #undef acosh</span>
<span id="L1773"><span class="lineNum"> 1773</span> : #undef acoshf</span>
<span id="L1774"><span class="lineNum"> 1774</span> : #undef acoshl</span>
<span id="L1775"><span class="lineNum"> 1775</span> : #undef asinh</span>
<span id="L1776"><span class="lineNum"> 1776</span> : #undef asinhf</span>
<span id="L1777"><span class="lineNum"> 1777</span> : #undef asinhl</span>
<span id="L1778"><span class="lineNum"> 1778</span> : #undef atanh</span>
<span id="L1779"><span class="lineNum"> 1779</span> : #undef atanhf</span>
<span id="L1780"><span class="lineNum"> 1780</span> : #undef atanhl</span>
<span id="L1781"><span class="lineNum"> 1781</span> : #undef cbrt</span>
<span id="L1782"><span class="lineNum"> 1782</span> : #undef cbrtf</span>
<span id="L1783"><span class="lineNum"> 1783</span> : #undef cbrtl</span>
<span id="L1784"><span class="lineNum"> 1784</span> : #undef copysign</span>
<span id="L1785"><span class="lineNum"> 1785</span> : #undef copysignf</span>
<span id="L1786"><span class="lineNum"> 1786</span> : #undef copysignl</span>
<span id="L1787"><span class="lineNum"> 1787</span> : #undef erf</span>
<span id="L1788"><span class="lineNum"> 1788</span> : #undef erff</span>
<span id="L1789"><span class="lineNum"> 1789</span> : #undef erfl</span>
<span id="L1790"><span class="lineNum"> 1790</span> : #undef erfc</span>
<span id="L1791"><span class="lineNum"> 1791</span> : #undef erfcf</span>
<span id="L1792"><span class="lineNum"> 1792</span> : #undef erfcl</span>
<span id="L1793"><span class="lineNum"> 1793</span> : #undef exp2</span>
<span id="L1794"><span class="lineNum"> 1794</span> : #undef exp2f</span>
<span id="L1795"><span class="lineNum"> 1795</span> : #undef exp2l</span>
<span id="L1796"><span class="lineNum"> 1796</span> : #undef expm1</span>
<span id="L1797"><span class="lineNum"> 1797</span> : #undef expm1f</span>
<span id="L1798"><span class="lineNum"> 1798</span> : #undef expm1l</span>
<span id="L1799"><span class="lineNum"> 1799</span> : #undef fdim</span>
<span id="L1800"><span class="lineNum"> 1800</span> : #undef fdimf</span>
<span id="L1801"><span class="lineNum"> 1801</span> : #undef fdiml</span>
<span id="L1802"><span class="lineNum"> 1802</span> : #undef fma</span>
<span id="L1803"><span class="lineNum"> 1803</span> : #undef fmaf</span>
<span id="L1804"><span class="lineNum"> 1804</span> : #undef fmal</span>
<span id="L1805"><span class="lineNum"> 1805</span> : #undef fmax</span>
<span id="L1806"><span class="lineNum"> 1806</span> : #undef fmaxf</span>
<span id="L1807"><span class="lineNum"> 1807</span> : #undef fmaxl</span>
<span id="L1808"><span class="lineNum"> 1808</span> : #undef fmin</span>
<span id="L1809"><span class="lineNum"> 1809</span> : #undef fminf</span>
<span id="L1810"><span class="lineNum"> 1810</span> : #undef fminl</span>
<span id="L1811"><span class="lineNum"> 1811</span> : #undef hypot</span>
<span id="L1812"><span class="lineNum"> 1812</span> : #undef hypotf</span>
<span id="L1813"><span class="lineNum"> 1813</span> : #undef hypotl</span>
<span id="L1814"><span class="lineNum"> 1814</span> : #undef ilogb</span>
<span id="L1815"><span class="lineNum"> 1815</span> : #undef ilogbf</span>
<span id="L1816"><span class="lineNum"> 1816</span> : #undef ilogbl</span>
<span id="L1817"><span class="lineNum"> 1817</span> : #undef lgamma</span>
<span id="L1818"><span class="lineNum"> 1818</span> : #undef lgammaf</span>
<span id="L1819"><span class="lineNum"> 1819</span> : #undef lgammal</span>
<span id="L1820"><span class="lineNum"> 1820</span> : #ifndef _GLIBCXX_NO_C99_ROUNDING_FUNCS</span>
<span id="L1821"><span class="lineNum"> 1821</span> : #undef llrint</span>
<span id="L1822"><span class="lineNum"> 1822</span> : #undef llrintf</span>
<span id="L1823"><span class="lineNum"> 1823</span> : #undef llrintl</span>
<span id="L1824"><span class="lineNum"> 1824</span> : #undef llround</span>
<span id="L1825"><span class="lineNum"> 1825</span> : #undef llroundf</span>
<span id="L1826"><span class="lineNum"> 1826</span> : #undef llroundl</span>
<span id="L1827"><span class="lineNum"> 1827</span> : #endif</span>
<span id="L1828"><span class="lineNum"> 1828</span> : #undef log1p</span>
<span id="L1829"><span class="lineNum"> 1829</span> : #undef log1pf</span>
<span id="L1830"><span class="lineNum"> 1830</span> : #undef log1pl</span>
<span id="L1831"><span class="lineNum"> 1831</span> : #undef log2</span>
<span id="L1832"><span class="lineNum"> 1832</span> : #undef log2f</span>
<span id="L1833"><span class="lineNum"> 1833</span> : #undef log2l</span>
<span id="L1834"><span class="lineNum"> 1834</span> : #undef logb</span>
<span id="L1835"><span class="lineNum"> 1835</span> : #undef logbf</span>
<span id="L1836"><span class="lineNum"> 1836</span> : #undef logbl</span>
<span id="L1837"><span class="lineNum"> 1837</span> : #undef lrint</span>
<span id="L1838"><span class="lineNum"> 1838</span> : #undef lrintf</span>
<span id="L1839"><span class="lineNum"> 1839</span> : #undef lrintl</span>
<span id="L1840"><span class="lineNum"> 1840</span> : #undef lround</span>
<span id="L1841"><span class="lineNum"> 1841</span> : #undef lroundf</span>
<span id="L1842"><span class="lineNum"> 1842</span> : #undef lroundl</span>
<span id="L1843"><span class="lineNum"> 1843</span> : #undef nan</span>
<span id="L1844"><span class="lineNum"> 1844</span> : #undef nanf</span>
<span id="L1845"><span class="lineNum"> 1845</span> : #undef nanl</span>
<span id="L1846"><span class="lineNum"> 1846</span> : #undef nearbyint</span>
<span id="L1847"><span class="lineNum"> 1847</span> : #undef nearbyintf</span>
<span id="L1848"><span class="lineNum"> 1848</span> : #undef nearbyintl</span>
<span id="L1849"><span class="lineNum"> 1849</span> : #undef nextafter</span>
<span id="L1850"><span class="lineNum"> 1850</span> : #undef nextafterf</span>
<span id="L1851"><span class="lineNum"> 1851</span> : #undef nextafterl</span>
<span id="L1852"><span class="lineNum"> 1852</span> : #undef nexttoward</span>
<span id="L1853"><span class="lineNum"> 1853</span> : #undef nexttowardf</span>
<span id="L1854"><span class="lineNum"> 1854</span> : #undef nexttowardl</span>
<span id="L1855"><span class="lineNum"> 1855</span> : #undef remainder</span>
<span id="L1856"><span class="lineNum"> 1856</span> : #undef remainderf</span>
<span id="L1857"><span class="lineNum"> 1857</span> : #undef remainderl</span>
<span id="L1858"><span class="lineNum"> 1858</span> : #undef remquo</span>
<span id="L1859"><span class="lineNum"> 1859</span> : #undef remquof</span>
<span id="L1860"><span class="lineNum"> 1860</span> : #undef remquol</span>
<span id="L1861"><span class="lineNum"> 1861</span> : #undef rint</span>
<span id="L1862"><span class="lineNum"> 1862</span> : #undef rintf</span>
<span id="L1863"><span class="lineNum"> 1863</span> : #undef rintl</span>
<span id="L1864"><span class="lineNum"> 1864</span> : #undef round</span>
<span id="L1865"><span class="lineNum"> 1865</span> : #undef roundf</span>
<span id="L1866"><span class="lineNum"> 1866</span> : #undef roundl</span>
<span id="L1867"><span class="lineNum"> 1867</span> : #undef scalbln</span>
<span id="L1868"><span class="lineNum"> 1868</span> : #undef scalblnf</span>
<span id="L1869"><span class="lineNum"> 1869</span> : #undef scalblnl</span>
<span id="L1870"><span class="lineNum"> 1870</span> : #undef scalbn</span>
<span id="L1871"><span class="lineNum"> 1871</span> : #undef scalbnf</span>
<span id="L1872"><span class="lineNum"> 1872</span> : #undef scalbnl</span>
<span id="L1873"><span class="lineNum"> 1873</span> : #undef tgamma</span>
<span id="L1874"><span class="lineNum"> 1874</span> : #undef tgammaf</span>
<span id="L1875"><span class="lineNum"> 1875</span> : #undef tgammal</span>
<span id="L1876"><span class="lineNum"> 1876</span> : #undef trunc</span>
<span id="L1877"><span class="lineNum"> 1877</span> : #undef truncf</span>
<span id="L1878"><span class="lineNum"> 1878</span> : #undef truncl</span>
<span id="L1879"><span class="lineNum"> 1879</span> : </span>
<span id="L1880"><span class="lineNum"> 1880</span> : // types</span>
<span id="L1881"><span class="lineNum"> 1881</span> : using ::double_t;</span>
<span id="L1882"><span class="lineNum"> 1882</span> : using ::float_t;</span>
<span id="L1883"><span class="lineNum"> 1883</span> : </span>
<span id="L1884"><span class="lineNum"> 1884</span> : // functions</span>
<span id="L1885"><span class="lineNum"> 1885</span> : using ::acosh;</span>
<span id="L1886"><span class="lineNum"> 1886</span> : using ::acoshf;</span>
<span id="L1887"><span class="lineNum"> 1887</span> : using ::acoshl;</span>
<span id="L1888"><span class="lineNum"> 1888</span> : </span>
<span id="L1889"><span class="lineNum"> 1889</span> : using ::asinh;</span>
<span id="L1890"><span class="lineNum"> 1890</span> : using ::asinhf;</span>
<span id="L1891"><span class="lineNum"> 1891</span> : using ::asinhl;</span>
<span id="L1892"><span class="lineNum"> 1892</span> : </span>
<span id="L1893"><span class="lineNum"> 1893</span> : using ::atanh;</span>
<span id="L1894"><span class="lineNum"> 1894</span> : using ::atanhf;</span>
<span id="L1895"><span class="lineNum"> 1895</span> : using ::atanhl;</span>
<span id="L1896"><span class="lineNum"> 1896</span> : </span>
<span id="L1897"><span class="lineNum"> 1897</span> : using ::cbrt;</span>
<span id="L1898"><span class="lineNum"> 1898</span> : using ::cbrtf;</span>
<span id="L1899"><span class="lineNum"> 1899</span> : using ::cbrtl;</span>
<span id="L1900"><span class="lineNum"> 1900</span> : </span>
<span id="L1901"><span class="lineNum"> 1901</span> : using ::copysign;</span>
<span id="L1902"><span class="lineNum"> 1902</span> : using ::copysignf;</span>
<span id="L1903"><span class="lineNum"> 1903</span> : using ::copysignl;</span>
<span id="L1904"><span class="lineNum"> 1904</span> : </span>
<span id="L1905"><span class="lineNum"> 1905</span> : using ::erf;</span>
<span id="L1906"><span class="lineNum"> 1906</span> : using ::erff;</span>
<span id="L1907"><span class="lineNum"> 1907</span> : using ::erfl;</span>
<span id="L1908"><span class="lineNum"> 1908</span> : </span>
<span id="L1909"><span class="lineNum"> 1909</span> : using ::erfc;</span>
<span id="L1910"><span class="lineNum"> 1910</span> : using ::erfcf;</span>
<span id="L1911"><span class="lineNum"> 1911</span> : using ::erfcl;</span>
<span id="L1912"><span class="lineNum"> 1912</span> : </span>
<span id="L1913"><span class="lineNum"> 1913</span> : using ::exp2;</span>
<span id="L1914"><span class="lineNum"> 1914</span> : using ::exp2f;</span>
<span id="L1915"><span class="lineNum"> 1915</span> : using ::exp2l;</span>
<span id="L1916"><span class="lineNum"> 1916</span> : </span>
<span id="L1917"><span class="lineNum"> 1917</span> : using ::expm1;</span>
<span id="L1918"><span class="lineNum"> 1918</span> : using ::expm1f;</span>
<span id="L1919"><span class="lineNum"> 1919</span> : using ::expm1l;</span>
<span id="L1920"><span class="lineNum"> 1920</span> : </span>
<span id="L1921"><span class="lineNum"> 1921</span> : using ::fdim;</span>
<span id="L1922"><span class="lineNum"> 1922</span> : using ::fdimf;</span>
<span id="L1923"><span class="lineNum"> 1923</span> : using ::fdiml;</span>
<span id="L1924"><span class="lineNum"> 1924</span> : </span>
<span id="L1925"><span class="lineNum"> 1925</span> : using ::fma;</span>
<span id="L1926"><span class="lineNum"> 1926</span> : using ::fmaf;</span>
<span id="L1927"><span class="lineNum"> 1927</span> : using ::fmal;</span>
<span id="L1928"><span class="lineNum"> 1928</span> : </span>
<span id="L1929"><span class="lineNum"> 1929</span> : using ::fmax;</span>
<span id="L1930"><span class="lineNum"> 1930</span> : using ::fmaxf;</span>
<span id="L1931"><span class="lineNum"> 1931</span> : using ::fmaxl;</span>
<span id="L1932"><span class="lineNum"> 1932</span> : </span>
<span id="L1933"><span class="lineNum"> 1933</span> : using ::fmin;</span>
<span id="L1934"><span class="lineNum"> 1934</span> : using ::fminf;</span>
<span id="L1935"><span class="lineNum"> 1935</span> : using ::fminl;</span>
<span id="L1936"><span class="lineNum"> 1936</span> : </span>
<span id="L1937"><span class="lineNum"> 1937</span> : using ::hypot;</span>
<span id="L1938"><span class="lineNum"> 1938</span> : using ::hypotf;</span>
<span id="L1939"><span class="lineNum"> 1939</span> : using ::hypotl;</span>
<span id="L1940"><span class="lineNum"> 1940</span> : </span>
<span id="L1941"><span class="lineNum"> 1941</span> : using ::ilogb;</span>
<span id="L1942"><span class="lineNum"> 1942</span> : using ::ilogbf;</span>
<span id="L1943"><span class="lineNum"> 1943</span> : using ::ilogbl;</span>
<span id="L1944"><span class="lineNum"> 1944</span> : </span>
<span id="L1945"><span class="lineNum"> 1945</span> : using ::lgamma;</span>
<span id="L1946"><span class="lineNum"> 1946</span> : using ::lgammaf;</span>
<span id="L1947"><span class="lineNum"> 1947</span> : using ::lgammal;</span>
<span id="L1948"><span class="lineNum"> 1948</span> : </span>
<span id="L1949"><span class="lineNum"> 1949</span> : #ifndef _GLIBCXX_NO_C99_ROUNDING_FUNCS</span>
<span id="L1950"><span class="lineNum"> 1950</span> : using ::llrint;</span>
<span id="L1951"><span class="lineNum"> 1951</span> : using ::llrintf;</span>
<span id="L1952"><span class="lineNum"> 1952</span> : using ::llrintl;</span>
<span id="L1953"><span class="lineNum"> 1953</span> : </span>
<span id="L1954"><span class="lineNum"> 1954</span> : using ::llround;</span>
<span id="L1955"><span class="lineNum"> 1955</span> : using ::llroundf;</span>
<span id="L1956"><span class="lineNum"> 1956</span> : using ::llroundl;</span>
<span id="L1957"><span class="lineNum"> 1957</span> : #endif</span>
<span id="L1958"><span class="lineNum"> 1958</span> : </span>
<span id="L1959"><span class="lineNum"> 1959</span> : using ::log1p;</span>
<span id="L1960"><span class="lineNum"> 1960</span> : using ::log1pf;</span>
<span id="L1961"><span class="lineNum"> 1961</span> : using ::log1pl;</span>
<span id="L1962"><span class="lineNum"> 1962</span> : </span>
<span id="L1963"><span class="lineNum"> 1963</span> : using ::log2;</span>
<span id="L1964"><span class="lineNum"> 1964</span> : using ::log2f;</span>
<span id="L1965"><span class="lineNum"> 1965</span> : using ::log2l;</span>
<span id="L1966"><span class="lineNum"> 1966</span> : </span>
<span id="L1967"><span class="lineNum"> 1967</span> : using ::logb;</span>
<span id="L1968"><span class="lineNum"> 1968</span> : using ::logbf;</span>
<span id="L1969"><span class="lineNum"> 1969</span> : using ::logbl;</span>
<span id="L1970"><span class="lineNum"> 1970</span> : </span>
<span id="L1971"><span class="lineNum"> 1971</span> : using ::lrint;</span>
<span id="L1972"><span class="lineNum"> 1972</span> : using ::lrintf;</span>
<span id="L1973"><span class="lineNum"> 1973</span> : using ::lrintl;</span>
<span id="L1974"><span class="lineNum"> 1974</span> : </span>
<span id="L1975"><span class="lineNum"> 1975</span> : using ::lround;</span>
<span id="L1976"><span class="lineNum"> 1976</span> : using ::lroundf;</span>
<span id="L1977"><span class="lineNum"> 1977</span> : using ::lroundl;</span>
<span id="L1978"><span class="lineNum"> 1978</span> : </span>
<span id="L1979"><span class="lineNum"> 1979</span> : using ::nan;</span>
<span id="L1980"><span class="lineNum"> 1980</span> : using ::nanf;</span>
<span id="L1981"><span class="lineNum"> 1981</span> : using ::nanl;</span>
<span id="L1982"><span class="lineNum"> 1982</span> : </span>
<span id="L1983"><span class="lineNum"> 1983</span> : using ::nearbyint;</span>
<span id="L1984"><span class="lineNum"> 1984</span> : using ::nearbyintf;</span>
<span id="L1985"><span class="lineNum"> 1985</span> : using ::nearbyintl;</span>
<span id="L1986"><span class="lineNum"> 1986</span> : </span>
<span id="L1987"><span class="lineNum"> 1987</span> : using ::nextafter;</span>
<span id="L1988"><span class="lineNum"> 1988</span> : using ::nextafterf;</span>
<span id="L1989"><span class="lineNum"> 1989</span> : using ::nextafterl;</span>
<span id="L1990"><span class="lineNum"> 1990</span> : </span>
<span id="L1991"><span class="lineNum"> 1991</span> : using ::nexttoward;</span>
<span id="L1992"><span class="lineNum"> 1992</span> : using ::nexttowardf;</span>
<span id="L1993"><span class="lineNum"> 1993</span> : using ::nexttowardl;</span>
<span id="L1994"><span class="lineNum"> 1994</span> : </span>
<span id="L1995"><span class="lineNum"> 1995</span> : using ::remainder;</span>
<span id="L1996"><span class="lineNum"> 1996</span> : using ::remainderf;</span>
<span id="L1997"><span class="lineNum"> 1997</span> : using ::remainderl;</span>
<span id="L1998"><span class="lineNum"> 1998</span> : </span>
<span id="L1999"><span class="lineNum"> 1999</span> : using ::remquo;</span>
<span id="L2000"><span class="lineNum"> 2000</span> : using ::remquof;</span>
<span id="L2001"><span class="lineNum"> 2001</span> : using ::remquol;</span>
<span id="L2002"><span class="lineNum"> 2002</span> : </span>
<span id="L2003"><span class="lineNum"> 2003</span> : using ::rint;</span>
<span id="L2004"><span class="lineNum"> 2004</span> : using ::rintf;</span>
<span id="L2005"><span class="lineNum"> 2005</span> : using ::rintl;</span>
<span id="L2006"><span class="lineNum"> 2006</span> : </span>
<span id="L2007"><span class="lineNum"> 2007</span> : using ::round;</span>
<span id="L2008"><span class="lineNum"> 2008</span> : using ::roundf;</span>
<span id="L2009"><span class="lineNum"> 2009</span> : using ::roundl;</span>
<span id="L2010"><span class="lineNum"> 2010</span> : </span>
<span id="L2011"><span class="lineNum"> 2011</span> : using ::scalbln;</span>
<span id="L2012"><span class="lineNum"> 2012</span> : using ::scalblnf;</span>
<span id="L2013"><span class="lineNum"> 2013</span> : using ::scalblnl;</span>
<span id="L2014"><span class="lineNum"> 2014</span> : </span>
<span id="L2015"><span class="lineNum"> 2015</span> : using ::scalbn;</span>
<span id="L2016"><span class="lineNum"> 2016</span> : using ::scalbnf;</span>
<span id="L2017"><span class="lineNum"> 2017</span> : using ::scalbnl;</span>
<span id="L2018"><span class="lineNum"> 2018</span> : </span>
<span id="L2019"><span class="lineNum"> 2019</span> : using ::tgamma;</span>
<span id="L2020"><span class="lineNum"> 2020</span> : using ::tgammaf;</span>
<span id="L2021"><span class="lineNum"> 2021</span> : using ::tgammal;</span>
<span id="L2022"><span class="lineNum"> 2022</span> : </span>
<span id="L2023"><span class="lineNum"> 2023</span> : using ::trunc;</span>
<span id="L2024"><span class="lineNum"> 2024</span> : using ::truncf;</span>
<span id="L2025"><span class="lineNum"> 2025</span> : using ::truncl;</span>
<span id="L2026"><span class="lineNum"> 2026</span> : </span>
<span id="L2027"><span class="lineNum"> 2027</span> : /// Additional overloads.</span>
<span id="L2028"><span class="lineNum"> 2028</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP</span>
<span id="L2029"><span class="lineNum"> 2029</span> : constexpr float</span>
<span id="L2030"><span class="lineNum"> 2030</span> : acosh(float __x)</span>
<span id="L2031"><span class="lineNum"> 2031</span> : { return __builtin_acoshf(__x); }</span>
<span id="L2032"><span class="lineNum"> 2032</span> : </span>
<span id="L2033"><span class="lineNum"> 2033</span> : constexpr long double</span>
<span id="L2034"><span class="lineNum"> 2034</span> : acosh(long double __x)</span>
<span id="L2035"><span class="lineNum"> 2035</span> : { return __builtin_acoshl(__x); }</span>
<span id="L2036"><span class="lineNum"> 2036</span> : #endif</span>
<span id="L2037"><span class="lineNum"> 2037</span> : </span>
<span id="L2038"><span class="lineNum"> 2038</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT</span>
<span id="L2039"><span class="lineNum"> 2039</span> : template&lt;typename _Tp&gt;</span>
<span id="L2040"><span class="lineNum"> 2040</span> : constexpr typename __gnu_cxx::__enable_if&lt;__is_integer&lt;_Tp&gt;::__value, </span>
<span id="L2041"><span class="lineNum"> 2041</span> : double&gt;::__type</span>
<span id="L2042"><span class="lineNum"> 2042</span> : acosh(_Tp __x)</span>
<span id="L2043"><span class="lineNum"> 2043</span> : { return __builtin_acosh(__x); }</span>
<span id="L2044"><span class="lineNum"> 2044</span> : #endif</span>
<span id="L2045"><span class="lineNum"> 2045</span> : </span>
<span id="L2046"><span class="lineNum"> 2046</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP</span>
<span id="L2047"><span class="lineNum"> 2047</span> : constexpr float</span>
<span id="L2048"><span class="lineNum"> 2048</span> : asinh(float __x)</span>
<span id="L2049"><span class="lineNum"> 2049</span> : { return __builtin_asinhf(__x); }</span>
<span id="L2050"><span class="lineNum"> 2050</span> : </span>
<span id="L2051"><span class="lineNum"> 2051</span> : constexpr long double</span>
<span id="L2052"><span class="lineNum"> 2052</span> : asinh(long double __x)</span>
<span id="L2053"><span class="lineNum"> 2053</span> : { return __builtin_asinhl(__x); }</span>
<span id="L2054"><span class="lineNum"> 2054</span> : #endif</span>
<span id="L2055"><span class="lineNum"> 2055</span> : </span>
<span id="L2056"><span class="lineNum"> 2056</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT</span>
<span id="L2057"><span class="lineNum"> 2057</span> : template&lt;typename _Tp&gt;</span>
<span id="L2058"><span class="lineNum"> 2058</span> : constexpr typename __gnu_cxx::__enable_if&lt;__is_integer&lt;_Tp&gt;::__value, </span>
<span id="L2059"><span class="lineNum"> 2059</span> : double&gt;::__type</span>
<span id="L2060"><span class="lineNum"> 2060</span> : asinh(_Tp __x)</span>
<span id="L2061"><span class="lineNum"> 2061</span> : { return __builtin_asinh(__x); }</span>
<span id="L2062"><span class="lineNum"> 2062</span> : #endif</span>
<span id="L2063"><span class="lineNum"> 2063</span> : </span>
<span id="L2064"><span class="lineNum"> 2064</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP</span>
<span id="L2065"><span class="lineNum"> 2065</span> : constexpr float</span>
<span id="L2066"><span class="lineNum"> 2066</span> : atanh(float __x)</span>
<span id="L2067"><span class="lineNum"> 2067</span> : { return __builtin_atanhf(__x); }</span>
<span id="L2068"><span class="lineNum"> 2068</span> : </span>
<span id="L2069"><span class="lineNum"> 2069</span> : constexpr long double</span>
<span id="L2070"><span class="lineNum"> 2070</span> : atanh(long double __x)</span>
<span id="L2071"><span class="lineNum"> 2071</span> : { return __builtin_atanhl(__x); }</span>
<span id="L2072"><span class="lineNum"> 2072</span> : #endif</span>
<span id="L2073"><span class="lineNum"> 2073</span> : </span>
<span id="L2074"><span class="lineNum"> 2074</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT</span>
<span id="L2075"><span class="lineNum"> 2075</span> : template&lt;typename _Tp&gt;</span>
<span id="L2076"><span class="lineNum"> 2076</span> : constexpr typename __gnu_cxx::__enable_if&lt;__is_integer&lt;_Tp&gt;::__value, </span>
<span id="L2077"><span class="lineNum"> 2077</span> : double&gt;::__type</span>
<span id="L2078"><span class="lineNum"> 2078</span> : atanh(_Tp __x)</span>
<span id="L2079"><span class="lineNum"> 2079</span> : { return __builtin_atanh(__x); }</span>
<span id="L2080"><span class="lineNum"> 2080</span> : #endif</span>
<span id="L2081"><span class="lineNum"> 2081</span> : </span>
<span id="L2082"><span class="lineNum"> 2082</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP</span>
<span id="L2083"><span class="lineNum"> 2083</span> : constexpr float</span>
<span id="L2084"><span class="lineNum"> 2084</span> : cbrt(float __x)</span>
<span id="L2085"><span class="lineNum"> 2085</span> : { return __builtin_cbrtf(__x); }</span>
<span id="L2086"><span class="lineNum"> 2086</span> : </span>
<span id="L2087"><span class="lineNum"> 2087</span> : constexpr long double</span>
<span id="L2088"><span class="lineNum"> 2088</span> : cbrt(long double __x)</span>
<span id="L2089"><span class="lineNum"> 2089</span> : { return __builtin_cbrtl(__x); }</span>
<span id="L2090"><span class="lineNum"> 2090</span> : #endif</span>
<span id="L2091"><span class="lineNum"> 2091</span> : </span>
<span id="L2092"><span class="lineNum"> 2092</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT</span>
<span id="L2093"><span class="lineNum"> 2093</span> : template&lt;typename _Tp&gt;</span>
<span id="L2094"><span class="lineNum"> 2094</span> : constexpr typename __gnu_cxx::__enable_if&lt;__is_integer&lt;_Tp&gt;::__value, </span>
<span id="L2095"><span class="lineNum"> 2095</span> : double&gt;::__type</span>
<span id="L2096"><span class="lineNum"> 2096</span> : cbrt(_Tp __x)</span>
<span id="L2097"><span class="lineNum"> 2097</span> : { return __builtin_cbrt(__x); }</span>
<span id="L2098"><span class="lineNum"> 2098</span> : #endif</span>
<span id="L2099"><span class="lineNum"> 2099</span> : </span>
<span id="L2100"><span class="lineNum"> 2100</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP</span>
<span id="L2101"><span class="lineNum"> 2101</span> : constexpr float</span>
<span id="L2102"><span class="lineNum"> 2102</span> : copysign(float __x, float __y)</span>
<span id="L2103"><span class="lineNum"> 2103</span> : { return __builtin_copysignf(__x, __y); }</span>
<span id="L2104"><span class="lineNum"> 2104</span> : </span>
<span id="L2105"><span class="lineNum"> 2105</span> : constexpr long double</span>
<span id="L2106"><span class="lineNum"> 2106</span> : copysign(long double __x, long double __y)</span>
<span id="L2107"><span class="lineNum"> 2107</span> : { return __builtin_copysignl(__x, __y); }</span>
<span id="L2108"><span class="lineNum"> 2108</span> : #endif</span>
<span id="L2109"><span class="lineNum"> 2109</span> : </span>
<span id="L2110"><span class="lineNum"> 2110</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP</span>
<span id="L2111"><span class="lineNum"> 2111</span> : constexpr float</span>
<span id="L2112"><span class="lineNum"> 2112</span> : erf(float __x)</span>
<span id="L2113"><span class="lineNum"> 2113</span> : { return __builtin_erff(__x); }</span>
<span id="L2114"><span class="lineNum"> 2114</span> : </span>
<span id="L2115"><span class="lineNum"> 2115</span> : constexpr long double</span>
<span id="L2116"><span class="lineNum"> 2116</span> : erf(long double __x)</span>
<span id="L2117"><span class="lineNum"> 2117</span> : { return __builtin_erfl(__x); }</span>
<span id="L2118"><span class="lineNum"> 2118</span> : #endif</span>
<span id="L2119"><span class="lineNum"> 2119</span> : </span>
<span id="L2120"><span class="lineNum"> 2120</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT</span>
<span id="L2121"><span class="lineNum"> 2121</span> : template&lt;typename _Tp&gt;</span>
<span id="L2122"><span class="lineNum"> 2122</span> : constexpr typename __gnu_cxx::__enable_if&lt;__is_integer&lt;_Tp&gt;::__value, </span>
<span id="L2123"><span class="lineNum"> 2123</span> : double&gt;::__type</span>
<span id="L2124"><span class="lineNum"> 2124</span> : erf(_Tp __x)</span>
<span id="L2125"><span class="lineNum"> 2125</span> : { return __builtin_erf(__x); }</span>
<span id="L2126"><span class="lineNum"> 2126</span> : #endif</span>
<span id="L2127"><span class="lineNum"> 2127</span> : </span>
<span id="L2128"><span class="lineNum"> 2128</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP</span>
<span id="L2129"><span class="lineNum"> 2129</span> : constexpr float</span>
<span id="L2130"><span class="lineNum"> 2130</span> : erfc(float __x)</span>
<span id="L2131"><span class="lineNum"> 2131</span> : { return __builtin_erfcf(__x); }</span>
<span id="L2132"><span class="lineNum"> 2132</span> : </span>
<span id="L2133"><span class="lineNum"> 2133</span> : constexpr long double</span>
<span id="L2134"><span class="lineNum"> 2134</span> : erfc(long double __x)</span>
<span id="L2135"><span class="lineNum"> 2135</span> : { return __builtin_erfcl(__x); }</span>
<span id="L2136"><span class="lineNum"> 2136</span> : #endif</span>
<span id="L2137"><span class="lineNum"> 2137</span> : </span>
<span id="L2138"><span class="lineNum"> 2138</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT</span>
<span id="L2139"><span class="lineNum"> 2139</span> : template&lt;typename _Tp&gt;</span>
<span id="L2140"><span class="lineNum"> 2140</span> : constexpr typename __gnu_cxx::__enable_if&lt;__is_integer&lt;_Tp&gt;::__value, </span>
<span id="L2141"><span class="lineNum"> 2141</span> : double&gt;::__type</span>
<span id="L2142"><span class="lineNum"> 2142</span> : erfc(_Tp __x)</span>
<span id="L2143"><span class="lineNum"> 2143</span> : { return __builtin_erfc(__x); }</span>
<span id="L2144"><span class="lineNum"> 2144</span> : #endif</span>
<span id="L2145"><span class="lineNum"> 2145</span> : </span>
<span id="L2146"><span class="lineNum"> 2146</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP</span>
<span id="L2147"><span class="lineNum"> 2147</span> : constexpr float</span>
<span id="L2148"><span class="lineNum"> 2148</span> : exp2(float __x)</span>
<span id="L2149"><span class="lineNum"> 2149</span> : { return __builtin_exp2f(__x); }</span>
<span id="L2150"><span class="lineNum"> 2150</span> : </span>
<span id="L2151"><span class="lineNum"> 2151</span> : constexpr long double</span>
<span id="L2152"><span class="lineNum"> 2152</span> : exp2(long double __x)</span>
<span id="L2153"><span class="lineNum"> 2153</span> : { return __builtin_exp2l(__x); }</span>
<span id="L2154"><span class="lineNum"> 2154</span> : #endif</span>
<span id="L2155"><span class="lineNum"> 2155</span> : </span>
<span id="L2156"><span class="lineNum"> 2156</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT</span>
<span id="L2157"><span class="lineNum"> 2157</span> : template&lt;typename _Tp&gt;</span>
<span id="L2158"><span class="lineNum"> 2158</span> : constexpr typename __gnu_cxx::__enable_if&lt;__is_integer&lt;_Tp&gt;::__value, </span>
<span id="L2159"><span class="lineNum"> 2159</span> : double&gt;::__type</span>
<span id="L2160"><span class="lineNum"> 2160</span> : exp2(_Tp __x)</span>
<span id="L2161"><span class="lineNum"> 2161</span> : { return __builtin_exp2(__x); }</span>
<span id="L2162"><span class="lineNum"> 2162</span> : #endif</span>
<span id="L2163"><span class="lineNum"> 2163</span> : </span>
<span id="L2164"><span class="lineNum"> 2164</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP</span>
<span id="L2165"><span class="lineNum"> 2165</span> : constexpr float</span>
<span id="L2166"><span class="lineNum"> 2166</span> : expm1(float __x)</span>
<span id="L2167"><span class="lineNum"> 2167</span> : { return __builtin_expm1f(__x); }</span>
<span id="L2168"><span class="lineNum"> 2168</span> : </span>
<span id="L2169"><span class="lineNum"> 2169</span> : constexpr long double</span>
<span id="L2170"><span class="lineNum"> 2170</span> : expm1(long double __x)</span>
<span id="L2171"><span class="lineNum"> 2171</span> : { return __builtin_expm1l(__x); }</span>
<span id="L2172"><span class="lineNum"> 2172</span> : #endif</span>
<span id="L2173"><span class="lineNum"> 2173</span> : </span>
<span id="L2174"><span class="lineNum"> 2174</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT</span>
<span id="L2175"><span class="lineNum"> 2175</span> : template&lt;typename _Tp&gt;</span>
<span id="L2176"><span class="lineNum"> 2176</span> : constexpr typename __gnu_cxx::__enable_if&lt;__is_integer&lt;_Tp&gt;::__value, </span>
<span id="L2177"><span class="lineNum"> 2177</span> : double&gt;::__type</span>
<span id="L2178"><span class="lineNum"> 2178</span> : expm1(_Tp __x)</span>
<span id="L2179"><span class="lineNum"> 2179</span> : { return __builtin_expm1(__x); }</span>
<span id="L2180"><span class="lineNum"> 2180</span> : #endif</span>
<span id="L2181"><span class="lineNum"> 2181</span> : </span>
<span id="L2182"><span class="lineNum"> 2182</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP</span>
<span id="L2183"><span class="lineNum"> 2183</span> : constexpr float</span>
<span id="L2184"><span class="lineNum"> 2184</span> : fdim(float __x, float __y)</span>
<span id="L2185"><span class="lineNum"> 2185</span> : { return __builtin_fdimf(__x, __y); }</span>
<span id="L2186"><span class="lineNum"> 2186</span> : </span>
<span id="L2187"><span class="lineNum"> 2187</span> : constexpr long double</span>
<span id="L2188"><span class="lineNum"> 2188</span> : fdim(long double __x, long double __y)</span>
<span id="L2189"><span class="lineNum"> 2189</span> : { return __builtin_fdiml(__x, __y); }</span>
<span id="L2190"><span class="lineNum"> 2190</span> : #endif</span>
<span id="L2191"><span class="lineNum"> 2191</span> : </span>
<span id="L2192"><span class="lineNum"> 2192</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP</span>
<span id="L2193"><span class="lineNum"> 2193</span> : constexpr float</span>
<span id="L2194"><span class="lineNum"> 2194</span> : fma(float __x, float __y, float __z)</span>
<span id="L2195"><span class="lineNum"> 2195</span> : { return __builtin_fmaf(__x, __y, __z); }</span>
<span id="L2196"><span class="lineNum"> 2196</span> : </span>
<span id="L2197"><span class="lineNum"> 2197</span> : constexpr long double</span>
<span id="L2198"><span class="lineNum"> 2198</span> : fma(long double __x, long double __y, long double __z)</span>
<span id="L2199"><span class="lineNum"> 2199</span> : { return __builtin_fmal(__x, __y, __z); }</span>
<span id="L2200"><span class="lineNum"> 2200</span> : #endif</span>
<span id="L2201"><span class="lineNum"> 2201</span> : </span>
<span id="L2202"><span class="lineNum"> 2202</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP</span>
<span id="L2203"><span class="lineNum"> 2203</span> : constexpr float</span>
<span id="L2204"><span class="lineNum"> 2204</span> : fmax(float __x, float __y)</span>
<span id="L2205"><span class="lineNum"> 2205</span> : { return __builtin_fmaxf(__x, __y); }</span>
<span id="L2206"><span class="lineNum"> 2206</span> : </span>
<span id="L2207"><span class="lineNum"> 2207</span> : constexpr long double</span>
<span id="L2208"><span class="lineNum"> 2208</span> : fmax(long double __x, long double __y)</span>
<span id="L2209"><span class="lineNum"> 2209</span> : { return __builtin_fmaxl(__x, __y); }</span>
<span id="L2210"><span class="lineNum"> 2210</span> : #endif</span>
<span id="L2211"><span class="lineNum"> 2211</span> : </span>
<span id="L2212"><span class="lineNum"> 2212</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP</span>
<span id="L2213"><span class="lineNum"> 2213</span> : constexpr float</span>
<span id="L2214"><span class="lineNum"> 2214</span> : fmin(float __x, float __y)</span>
<span id="L2215"><span class="lineNum"> 2215</span> : { return __builtin_fminf(__x, __y); }</span>
<span id="L2216"><span class="lineNum"> 2216</span> : </span>
<span id="L2217"><span class="lineNum"> 2217</span> : constexpr long double</span>
<span id="L2218"><span class="lineNum"> 2218</span> : fmin(long double __x, long double __y)</span>
<span id="L2219"><span class="lineNum"> 2219</span> : { return __builtin_fminl(__x, __y); }</span>
<span id="L2220"><span class="lineNum"> 2220</span> : #endif</span>
<span id="L2221"><span class="lineNum"> 2221</span> : </span>
<span id="L2222"><span class="lineNum"> 2222</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP</span>
<span id="L2223"><span class="lineNum"> 2223</span> : constexpr float</span>
<span id="L2224"><span class="lineNum"> 2224</span> : hypot(float __x, float __y)</span>
<span id="L2225"><span class="lineNum"> 2225</span> : { return __builtin_hypotf(__x, __y); }</span>
<span id="L2226"><span class="lineNum"> 2226</span> : </span>
<span id="L2227"><span class="lineNum"> 2227</span> : constexpr long double</span>
<span id="L2228"><span class="lineNum"> 2228</span> : hypot(long double __x, long double __y)</span>
<span id="L2229"><span class="lineNum"> 2229</span> : { return __builtin_hypotl(__x, __y); }</span>
<span id="L2230"><span class="lineNum"> 2230</span> : #endif</span>
<span id="L2231"><span class="lineNum"> 2231</span> : </span>
<span id="L2232"><span class="lineNum"> 2232</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP</span>
<span id="L2233"><span class="lineNum"> 2233</span> : constexpr int</span>
<span id="L2234"><span class="lineNum"> 2234</span> : ilogb(float __x)</span>
<span id="L2235"><span class="lineNum"> 2235</span> : { return __builtin_ilogbf(__x); }</span>
<span id="L2236"><span class="lineNum"> 2236</span> : </span>
<span id="L2237"><span class="lineNum"> 2237</span> : constexpr int</span>
<span id="L2238"><span class="lineNum"> 2238</span> : ilogb(long double __x)</span>
<span id="L2239"><span class="lineNum"> 2239</span> : { return __builtin_ilogbl(__x); }</span>
<span id="L2240"><span class="lineNum"> 2240</span> : #endif</span>
<span id="L2241"><span class="lineNum"> 2241</span> : </span>
<span id="L2242"><span class="lineNum"> 2242</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT</span>
<span id="L2243"><span class="lineNum"> 2243</span> : template&lt;typename _Tp&gt;</span>
<span id="L2244"><span class="lineNum"> 2244</span> : constexpr</span>
<span id="L2245"><span class="lineNum"> 2245</span> : typename __gnu_cxx::__enable_if&lt;__is_integer&lt;_Tp&gt;::__value, </span>
<span id="L2246"><span class="lineNum"> 2246</span> : int&gt;::__type</span>
<span id="L2247"><span class="lineNum"> 2247</span> : ilogb(_Tp __x)</span>
<span id="L2248"><span class="lineNum"> 2248</span> : { return __builtin_ilogb(__x); }</span>
<span id="L2249"><span class="lineNum"> 2249</span> : #endif</span>
<span id="L2250"><span class="lineNum"> 2250</span> : </span>
<span id="L2251"><span class="lineNum"> 2251</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP</span>
<span id="L2252"><span class="lineNum"> 2252</span> : constexpr float</span>
<span id="L2253"><span class="lineNum"> 2253</span> : lgamma(float __x)</span>
<span id="L2254"><span class="lineNum"> 2254</span> : { return __builtin_lgammaf(__x); }</span>
<span id="L2255"><span class="lineNum"> 2255</span> : </span>
<span id="L2256"><span class="lineNum"> 2256</span> : constexpr long double</span>
<span id="L2257"><span class="lineNum"> 2257</span> : lgamma(long double __x)</span>
<span id="L2258"><span class="lineNum"> 2258</span> : { return __builtin_lgammal(__x); }</span>
<span id="L2259"><span class="lineNum"> 2259</span> : #endif</span>
<span id="L2260"><span class="lineNum"> 2260</span> : </span>
<span id="L2261"><span class="lineNum"> 2261</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT</span>
<span id="L2262"><span class="lineNum"> 2262</span> : template&lt;typename _Tp&gt;</span>
<span id="L2263"><span class="lineNum"> 2263</span> : constexpr typename __gnu_cxx::__enable_if&lt;__is_integer&lt;_Tp&gt;::__value, </span>
<span id="L2264"><span class="lineNum"> 2264</span> : double&gt;::__type</span>
<span id="L2265"><span class="lineNum"> 2265</span> : lgamma(_Tp __x)</span>
<span id="L2266"><span class="lineNum"> 2266</span> : { return __builtin_lgamma(__x); }</span>
<span id="L2267"><span class="lineNum"> 2267</span> : #endif</span>
<span id="L2268"><span class="lineNum"> 2268</span> : </span>
<span id="L2269"><span class="lineNum"> 2269</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP</span>
<span id="L2270"><span class="lineNum"> 2270</span> : constexpr long long</span>
<span id="L2271"><span class="lineNum"> 2271</span> : llrint(float __x)</span>
<span id="L2272"><span class="lineNum"> 2272</span> : { return __builtin_llrintf(__x); }</span>
<span id="L2273"><span class="lineNum"> 2273</span> : </span>
<span id="L2274"><span class="lineNum"> 2274</span> : constexpr long long</span>
<span id="L2275"><span class="lineNum"> 2275</span> : llrint(long double __x)</span>
<span id="L2276"><span class="lineNum"> 2276</span> : { return __builtin_llrintl(__x); }</span>
<span id="L2277"><span class="lineNum"> 2277</span> : #endif</span>
<span id="L2278"><span class="lineNum"> 2278</span> : </span>
<span id="L2279"><span class="lineNum"> 2279</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT</span>
<span id="L2280"><span class="lineNum"> 2280</span> : template&lt;typename _Tp&gt;</span>
<span id="L2281"><span class="lineNum"> 2281</span> : constexpr typename __gnu_cxx::__enable_if&lt;__is_integer&lt;_Tp&gt;::__value, </span>
<span id="L2282"><span class="lineNum"> 2282</span> : long long&gt;::__type</span>
<span id="L2283"><span class="lineNum"> 2283</span> : llrint(_Tp __x)</span>
<span id="L2284"><span class="lineNum"> 2284</span> : { return __builtin_llrint(__x); }</span>
<span id="L2285"><span class="lineNum"> 2285</span> : #endif</span>
<span id="L2286"><span class="lineNum"> 2286</span> : </span>
<span id="L2287"><span class="lineNum"> 2287</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP</span>
<span id="L2288"><span class="lineNum"> 2288</span> : constexpr long long</span>
<span id="L2289"><span class="lineNum"> 2289</span> : llround(float __x)</span>
<span id="L2290"><span class="lineNum"> 2290</span> : { return __builtin_llroundf(__x); }</span>
<span id="L2291"><span class="lineNum"> 2291</span> : </span>
<span id="L2292"><span class="lineNum"> 2292</span> : constexpr long long</span>
<span id="L2293"><span class="lineNum"> 2293</span> : llround(long double __x)</span>
<span id="L2294"><span class="lineNum"> 2294</span> : { return __builtin_llroundl(__x); }</span>
<span id="L2295"><span class="lineNum"> 2295</span> : #endif</span>
<span id="L2296"><span class="lineNum"> 2296</span> : </span>
<span id="L2297"><span class="lineNum"> 2297</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT</span>
<span id="L2298"><span class="lineNum"> 2298</span> : template&lt;typename _Tp&gt;</span>
<span id="L2299"><span class="lineNum"> 2299</span> : constexpr typename __gnu_cxx::__enable_if&lt;__is_integer&lt;_Tp&gt;::__value, </span>
<span id="L2300"><span class="lineNum"> 2300</span> : long long&gt;::__type</span>
<span id="L2301"><span class="lineNum"> 2301</span> : llround(_Tp __x)</span>
<span id="L2302"><span class="lineNum"> 2302</span> : { return __builtin_llround(__x); }</span>
<span id="L2303"><span class="lineNum"> 2303</span> : #endif</span>
<span id="L2304"><span class="lineNum"> 2304</span> : </span>
<span id="L2305"><span class="lineNum"> 2305</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP</span>
<span id="L2306"><span class="lineNum"> 2306</span> : constexpr float</span>
<span id="L2307"><span class="lineNum"> 2307</span> : log1p(float __x)</span>
<span id="L2308"><span class="lineNum"> 2308</span> : { return __builtin_log1pf(__x); }</span>
<span id="L2309"><span class="lineNum"> 2309</span> : </span>
<span id="L2310"><span class="lineNum"> 2310</span> : constexpr long double</span>
<span id="L2311"><span class="lineNum"> 2311</span> : log1p(long double __x)</span>
<span id="L2312"><span class="lineNum"> 2312</span> : { return __builtin_log1pl(__x); }</span>
<span id="L2313"><span class="lineNum"> 2313</span> : #endif</span>
<span id="L2314"><span class="lineNum"> 2314</span> : </span>
<span id="L2315"><span class="lineNum"> 2315</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT</span>
<span id="L2316"><span class="lineNum"> 2316</span> : template&lt;typename _Tp&gt;</span>
<span id="L2317"><span class="lineNum"> 2317</span> : constexpr typename __gnu_cxx::__enable_if&lt;__is_integer&lt;_Tp&gt;::__value, </span>
<span id="L2318"><span class="lineNum"> 2318</span> : double&gt;::__type</span>
<span id="L2319"><span class="lineNum"> 2319</span> : log1p(_Tp __x)</span>
<span id="L2320"><span class="lineNum"> 2320</span> : { return __builtin_log1p(__x); }</span>
<span id="L2321"><span class="lineNum"> 2321</span> : #endif</span>
<span id="L2322"><span class="lineNum"> 2322</span> : </span>
<span id="L2323"><span class="lineNum"> 2323</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP</span>
<span id="L2324"><span class="lineNum"> 2324</span> : // DR 568.</span>
<span id="L2325"><span class="lineNum"> 2325</span> : constexpr float</span>
<span id="L2326"><span class="lineNum"> 2326</span> : log2(float __x)</span>
<span id="L2327"><span class="lineNum"> 2327</span> : { return __builtin_log2f(__x); }</span>
<span id="L2328"><span class="lineNum"> 2328</span> : </span>
<span id="L2329"><span class="lineNum"> 2329</span> : constexpr long double</span>
<span id="L2330"><span class="lineNum"> 2330</span> : log2(long double __x)</span>
<span id="L2331"><span class="lineNum"> 2331</span> : { return __builtin_log2l(__x); }</span>
<span id="L2332"><span class="lineNum"> 2332</span> : #endif</span>
<span id="L2333"><span class="lineNum"> 2333</span> : </span>
<span id="L2334"><span class="lineNum"> 2334</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT</span>
<span id="L2335"><span class="lineNum"> 2335</span> : template&lt;typename _Tp&gt;</span>
<span id="L2336"><span class="lineNum"> 2336</span> : constexpr typename __gnu_cxx::__enable_if&lt;__is_integer&lt;_Tp&gt;::__value, </span>
<span id="L2337"><span class="lineNum"> 2337</span> : double&gt;::__type</span>
<span id="L2338"><span class="lineNum"> 2338</span> : log2(_Tp __x)</span>
<span id="L2339"><span class="lineNum"> 2339</span> : { return __builtin_log2(__x); }</span>
<span id="L2340"><span class="lineNum"> 2340</span> : #endif</span>
<span id="L2341"><span class="lineNum"> 2341</span> : </span>
<span id="L2342"><span class="lineNum"> 2342</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP</span>
<span id="L2343"><span class="lineNum"> 2343</span> : constexpr float</span>
<span id="L2344"><span class="lineNum"> 2344</span> : logb(float __x)</span>
<span id="L2345"><span class="lineNum"> 2345</span> : { return __builtin_logbf(__x); }</span>
<span id="L2346"><span class="lineNum"> 2346</span> : </span>
<span id="L2347"><span class="lineNum"> 2347</span> : constexpr long double</span>
<span id="L2348"><span class="lineNum"> 2348</span> : logb(long double __x)</span>
<span id="L2349"><span class="lineNum"> 2349</span> : { return __builtin_logbl(__x); }</span>
<span id="L2350"><span class="lineNum"> 2350</span> : #endif</span>
<span id="L2351"><span class="lineNum"> 2351</span> : </span>
<span id="L2352"><span class="lineNum"> 2352</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT</span>
<span id="L2353"><span class="lineNum"> 2353</span> : template&lt;typename _Tp&gt;</span>
<span id="L2354"><span class="lineNum"> 2354</span> : constexpr typename __gnu_cxx::__enable_if&lt;__is_integer&lt;_Tp&gt;::__value, </span>
<span id="L2355"><span class="lineNum"> 2355</span> : double&gt;::__type</span>
<span id="L2356"><span class="lineNum"> 2356</span> : logb(_Tp __x)</span>
<span id="L2357"><span class="lineNum"> 2357</span> : { return __builtin_logb(__x); }</span>
<span id="L2358"><span class="lineNum"> 2358</span> : #endif</span>
<span id="L2359"><span class="lineNum"> 2359</span> : </span>
<span id="L2360"><span class="lineNum"> 2360</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP</span>
<span id="L2361"><span class="lineNum"> 2361</span> : constexpr long</span>
<span id="L2362"><span class="lineNum"> 2362</span> : lrint(float __x)</span>
<span id="L2363"><span class="lineNum"> 2363</span> : { return __builtin_lrintf(__x); }</span>
<span id="L2364"><span class="lineNum"> 2364</span> : </span>
<span id="L2365"><span class="lineNum"> 2365</span> : constexpr long</span>
<span id="L2366"><span class="lineNum"> 2366</span> : lrint(long double __x)</span>
<span id="L2367"><span class="lineNum"> 2367</span> : { return __builtin_lrintl(__x); }</span>
<span id="L2368"><span class="lineNum"> 2368</span> : #endif</span>
<span id="L2369"><span class="lineNum"> 2369</span> : </span>
<span id="L2370"><span class="lineNum"> 2370</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT</span>
<span id="L2371"><span class="lineNum"> 2371</span> : template&lt;typename _Tp&gt;</span>
<span id="L2372"><span class="lineNum"> 2372</span> : constexpr typename __gnu_cxx::__enable_if&lt;__is_integer&lt;_Tp&gt;::__value, </span>
<span id="L2373"><span class="lineNum"> 2373</span> : long&gt;::__type</span>
<span id="L2374"><span class="lineNum"> 2374</span> : lrint(_Tp __x)</span>
<span id="L2375"><span class="lineNum"> 2375</span> : { return __builtin_lrint(__x); }</span>
<span id="L2376"><span class="lineNum"> 2376</span> : #endif</span>
<span id="L2377"><span class="lineNum"> 2377</span> : </span>
<span id="L2378"><span class="lineNum"> 2378</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP</span>
<span id="L2379"><span class="lineNum"> 2379</span> : constexpr long</span>
<span id="L2380"><span class="lineNum"> 2380</span> : lround(float __x)</span>
<span id="L2381"><span class="lineNum"> 2381</span> : { return __builtin_lroundf(__x); }</span>
<span id="L2382"><span class="lineNum"> 2382</span> : </span>
<span id="L2383"><span class="lineNum"> 2383</span> : constexpr long</span>
<span id="L2384"><span class="lineNum"> 2384</span> : lround(long double __x)</span>
<span id="L2385"><span class="lineNum"> 2385</span> : { return __builtin_lroundl(__x); }</span>
<span id="L2386"><span class="lineNum"> 2386</span> : #endif</span>
<span id="L2387"><span class="lineNum"> 2387</span> : </span>
<span id="L2388"><span class="lineNum"> 2388</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT</span>
<span id="L2389"><span class="lineNum"> 2389</span> : template&lt;typename _Tp&gt;</span>
<span id="L2390"><span class="lineNum"> 2390</span> : constexpr typename __gnu_cxx::__enable_if&lt;__is_integer&lt;_Tp&gt;::__value, </span>
<span id="L2391"><span class="lineNum"> 2391</span> : long&gt;::__type</span>
<span id="L2392"><span class="lineNum"> 2392</span> : lround(_Tp __x)</span>
<span id="L2393"><span class="lineNum"> 2393</span> : { return __builtin_lround(__x); }</span>
<span id="L2394"><span class="lineNum"> 2394</span> : #endif</span>
<span id="L2395"><span class="lineNum"> 2395</span> : </span>
<span id="L2396"><span class="lineNum"> 2396</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP</span>
<span id="L2397"><span class="lineNum"> 2397</span> : constexpr float</span>
<span id="L2398"><span class="lineNum"> 2398</span> : nearbyint(float __x)</span>
<span id="L2399"><span class="lineNum"> 2399</span> : { return __builtin_nearbyintf(__x); }</span>
<span id="L2400"><span class="lineNum"> 2400</span> : </span>
<span id="L2401"><span class="lineNum"> 2401</span> : constexpr long double</span>
<span id="L2402"><span class="lineNum"> 2402</span> : nearbyint(long double __x)</span>
<span id="L2403"><span class="lineNum"> 2403</span> : { return __builtin_nearbyintl(__x); }</span>
<span id="L2404"><span class="lineNum"> 2404</span> : #endif</span>
<span id="L2405"><span class="lineNum"> 2405</span> : </span>
<span id="L2406"><span class="lineNum"> 2406</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT</span>
<span id="L2407"><span class="lineNum"> 2407</span> : template&lt;typename _Tp&gt;</span>
<span id="L2408"><span class="lineNum"> 2408</span> : constexpr typename __gnu_cxx::__enable_if&lt;__is_integer&lt;_Tp&gt;::__value, </span>
<span id="L2409"><span class="lineNum"> 2409</span> : double&gt;::__type</span>
<span id="L2410"><span class="lineNum"> 2410</span> : nearbyint(_Tp __x)</span>
<span id="L2411"><span class="lineNum"> 2411</span> : { return __builtin_nearbyint(__x); }</span>
<span id="L2412"><span class="lineNum"> 2412</span> : #endif</span>
<span id="L2413"><span class="lineNum"> 2413</span> : </span>
<span id="L2414"><span class="lineNum"> 2414</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP</span>
<span id="L2415"><span class="lineNum"> 2415</span> : constexpr float</span>
<span id="L2416"><span class="lineNum"> 2416</span> : nextafter(float __x, float __y)</span>
<span id="L2417"><span class="lineNum"> 2417</span> : { return __builtin_nextafterf(__x, __y); }</span>
<span id="L2418"><span class="lineNum"> 2418</span> : </span>
<span id="L2419"><span class="lineNum"> 2419</span> : constexpr long double</span>
<span id="L2420"><span class="lineNum"> 2420</span> : nextafter(long double __x, long double __y)</span>
<span id="L2421"><span class="lineNum"> 2421</span> : { return __builtin_nextafterl(__x, __y); }</span>
<span id="L2422"><span class="lineNum"> 2422</span> : #endif</span>
<span id="L2423"><span class="lineNum"> 2423</span> : </span>
<span id="L2424"><span class="lineNum"> 2424</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP</span>
<span id="L2425"><span class="lineNum"> 2425</span> : constexpr float</span>
<span id="L2426"><span class="lineNum"> 2426</span> : nexttoward(float __x, long double __y)</span>
<span id="L2427"><span class="lineNum"> 2427</span> : { return __builtin_nexttowardf(__x, __y); }</span>
<span id="L2428"><span class="lineNum"> 2428</span> : </span>
<span id="L2429"><span class="lineNum"> 2429</span> : constexpr long double</span>
<span id="L2430"><span class="lineNum"> 2430</span> : nexttoward(long double __x, long double __y)</span>
<span id="L2431"><span class="lineNum"> 2431</span> : { return __builtin_nexttowardl(__x, __y); }</span>
<span id="L2432"><span class="lineNum"> 2432</span> : #endif</span>
<span id="L2433"><span class="lineNum"> 2433</span> : </span>
<span id="L2434"><span class="lineNum"> 2434</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT</span>
<span id="L2435"><span class="lineNum"> 2435</span> : template&lt;typename _Tp&gt;</span>
<span id="L2436"><span class="lineNum"> 2436</span> : constexpr typename __gnu_cxx::__enable_if&lt;__is_integer&lt;_Tp&gt;::__value, </span>
<span id="L2437"><span class="lineNum"> 2437</span> : double&gt;::__type</span>
<span id="L2438"><span class="lineNum"> 2438</span> : nexttoward(_Tp __x, long double __y)</span>
<span id="L2439"><span class="lineNum"> 2439</span> : { return __builtin_nexttoward(__x, __y); }</span>
<span id="L2440"><span class="lineNum"> 2440</span> : #endif</span>
<span id="L2441"><span class="lineNum"> 2441</span> : </span>
<span id="L2442"><span class="lineNum"> 2442</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP</span>
<span id="L2443"><span class="lineNum"> 2443</span> : constexpr float</span>
<span id="L2444"><span class="lineNum"> 2444</span> : remainder(float __x, float __y)</span>
<span id="L2445"><span class="lineNum"> 2445</span> : { return __builtin_remainderf(__x, __y); }</span>
<span id="L2446"><span class="lineNum"> 2446</span> : </span>
<span id="L2447"><span class="lineNum"> 2447</span> : constexpr long double</span>
<span id="L2448"><span class="lineNum"> 2448</span> : remainder(long double __x, long double __y)</span>
<span id="L2449"><span class="lineNum"> 2449</span> : { return __builtin_remainderl(__x, __y); }</span>
<span id="L2450"><span class="lineNum"> 2450</span> : #endif</span>
<span id="L2451"><span class="lineNum"> 2451</span> : </span>
<span id="L2452"><span class="lineNum"> 2452</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP</span>
<span id="L2453"><span class="lineNum"> 2453</span> : inline float</span>
<span id="L2454"><span class="lineNum"> 2454</span> : remquo(float __x, float __y, int* __pquo)</span>
<span id="L2455"><span class="lineNum"> 2455</span> : { return __builtin_remquof(__x, __y, __pquo); }</span>
<span id="L2456"><span class="lineNum"> 2456</span> : </span>
<span id="L2457"><span class="lineNum"> 2457</span> : inline long double</span>
<span id="L2458"><span class="lineNum"> 2458</span> : remquo(long double __x, long double __y, int* __pquo)</span>
<span id="L2459"><span class="lineNum"> 2459</span> : { return __builtin_remquol(__x, __y, __pquo); }</span>
<span id="L2460"><span class="lineNum"> 2460</span> : #endif</span>
<span id="L2461"><span class="lineNum"> 2461</span> : </span>
<span id="L2462"><span class="lineNum"> 2462</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP</span>
<span id="L2463"><span class="lineNum"> 2463</span> : constexpr float</span>
<span id="L2464"><span class="lineNum"> 2464</span> : rint(float __x)</span>
<span id="L2465"><span class="lineNum"> 2465</span> : { return __builtin_rintf(__x); }</span>
<span id="L2466"><span class="lineNum"> 2466</span> : </span>
<span id="L2467"><span class="lineNum"> 2467</span> : constexpr long double</span>
<span id="L2468"><span class="lineNum"> 2468</span> : rint(long double __x)</span>
<span id="L2469"><span class="lineNum"> 2469</span> : { return __builtin_rintl(__x); }</span>
<span id="L2470"><span class="lineNum"> 2470</span> : #endif</span>
<span id="L2471"><span class="lineNum"> 2471</span> : </span>
<span id="L2472"><span class="lineNum"> 2472</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT</span>
<span id="L2473"><span class="lineNum"> 2473</span> : template&lt;typename _Tp&gt;</span>
<span id="L2474"><span class="lineNum"> 2474</span> : constexpr typename __gnu_cxx::__enable_if&lt;__is_integer&lt;_Tp&gt;::__value, </span>
<span id="L2475"><span class="lineNum"> 2475</span> : double&gt;::__type</span>
<span id="L2476"><span class="lineNum"> 2476</span> : rint(_Tp __x)</span>
<span id="L2477"><span class="lineNum"> 2477</span> : { return __builtin_rint(__x); }</span>
<span id="L2478"><span class="lineNum"> 2478</span> : #endif</span>
<span id="L2479"><span class="lineNum"> 2479</span> : </span>
<span id="L2480"><span class="lineNum"> 2480</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP</span>
<span id="L2481"><span class="lineNum"> 2481</span> : constexpr float</span>
<span id="L2482"><span class="lineNum"> 2482</span> : round(float __x)</span>
<span id="L2483"><span class="lineNum"> 2483</span> : { return __builtin_roundf(__x); }</span>
<span id="L2484"><span class="lineNum"> 2484</span> : </span>
<span id="L2485"><span class="lineNum"> 2485</span> : constexpr long double</span>
<span id="L2486"><span class="lineNum"> 2486</span> : round(long double __x)</span>
<span id="L2487"><span class="lineNum"> 2487</span> : { return __builtin_roundl(__x); }</span>
<span id="L2488"><span class="lineNum"> 2488</span> : #endif</span>
<span id="L2489"><span class="lineNum"> 2489</span> : </span>
<span id="L2490"><span class="lineNum"> 2490</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT</span>
<span id="L2491"><span class="lineNum"> 2491</span> : template&lt;typename _Tp&gt;</span>
<span id="L2492"><span class="lineNum"> 2492</span> : constexpr typename __gnu_cxx::__enable_if&lt;__is_integer&lt;_Tp&gt;::__value, </span>
<span id="L2493"><span class="lineNum"> 2493</span> : double&gt;::__type</span>
<span id="L2494"><span class="lineNum"> 2494</span> : round(_Tp __x)</span>
<span id="L2495"><span class="lineNum"> 2495</span> : { return __builtin_round(__x); }</span>
<span id="L2496"><span class="lineNum"> 2496</span> : #endif</span>
<span id="L2497"><span class="lineNum"> 2497</span> : </span>
<span id="L2498"><span class="lineNum"> 2498</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP</span>
<span id="L2499"><span class="lineNum"> 2499</span> : constexpr float</span>
<span id="L2500"><span class="lineNum"> 2500</span> : scalbln(float __x, long __ex)</span>
<span id="L2501"><span class="lineNum"> 2501</span> : { return __builtin_scalblnf(__x, __ex); }</span>
<span id="L2502"><span class="lineNum"> 2502</span> : </span>
<span id="L2503"><span class="lineNum"> 2503</span> : constexpr long double</span>
<span id="L2504"><span class="lineNum"> 2504</span> : scalbln(long double __x, long __ex)</span>
<span id="L2505"><span class="lineNum"> 2505</span> : { return __builtin_scalblnl(__x, __ex); }</span>
<span id="L2506"><span class="lineNum"> 2506</span> : #endif</span>
<span id="L2507"><span class="lineNum"> 2507</span> : </span>
<span id="L2508"><span class="lineNum"> 2508</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT</span>
<span id="L2509"><span class="lineNum"> 2509</span> : template&lt;typename _Tp&gt;</span>
<span id="L2510"><span class="lineNum"> 2510</span> : constexpr typename __gnu_cxx::__enable_if&lt;__is_integer&lt;_Tp&gt;::__value, </span>
<span id="L2511"><span class="lineNum"> 2511</span> : double&gt;::__type</span>
<span id="L2512"><span class="lineNum"> 2512</span> : scalbln(_Tp __x, long __ex)</span>
<span id="L2513"><span class="lineNum"> 2513</span> : { return __builtin_scalbln(__x, __ex); }</span>
<span id="L2514"><span class="lineNum"> 2514</span> : #endif</span>
<span id="L2515"><span class="lineNum"> 2515</span> : </span>
<span id="L2516"><span class="lineNum"> 2516</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP</span>
<span id="L2517"><span class="lineNum"> 2517</span> : constexpr float</span>
<span id="L2518"><span class="lineNum"> 2518</span> : scalbn(float __x, int __ex)</span>
<span id="L2519"><span class="lineNum"> 2519</span> : { return __builtin_scalbnf(__x, __ex); }</span>
<span id="L2520"><span class="lineNum"> 2520</span> : </span>
<span id="L2521"><span class="lineNum"> 2521</span> : constexpr long double</span>
<span id="L2522"><span class="lineNum"> 2522</span> : scalbn(long double __x, int __ex)</span>
<span id="L2523"><span class="lineNum"> 2523</span> : { return __builtin_scalbnl(__x, __ex); }</span>
<span id="L2524"><span class="lineNum"> 2524</span> : #endif</span>
<span id="L2525"><span class="lineNum"> 2525</span> : </span>
<span id="L2526"><span class="lineNum"> 2526</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT</span>
<span id="L2527"><span class="lineNum"> 2527</span> : template&lt;typename _Tp&gt;</span>
<span id="L2528"><span class="lineNum"> 2528</span> : constexpr typename __gnu_cxx::__enable_if&lt;__is_integer&lt;_Tp&gt;::__value, </span>
<span id="L2529"><span class="lineNum"> 2529</span> : double&gt;::__type</span>
<span id="L2530"><span class="lineNum"> 2530</span> : scalbn(_Tp __x, int __ex)</span>
<span id="L2531"><span class="lineNum"> 2531</span> : { return __builtin_scalbn(__x, __ex); }</span>
<span id="L2532"><span class="lineNum"> 2532</span> : #endif</span>
<span id="L2533"><span class="lineNum"> 2533</span> : </span>
<span id="L2534"><span class="lineNum"> 2534</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP</span>
<span id="L2535"><span class="lineNum"> 2535</span> : constexpr float</span>
<span id="L2536"><span class="lineNum"> 2536</span> : tgamma(float __x)</span>
<span id="L2537"><span class="lineNum"> 2537</span> : { return __builtin_tgammaf(__x); }</span>
<span id="L2538"><span class="lineNum"> 2538</span> : </span>
<span id="L2539"><span class="lineNum"> 2539</span> : constexpr long double</span>
<span id="L2540"><span class="lineNum"> 2540</span> : tgamma(long double __x)</span>
<span id="L2541"><span class="lineNum"> 2541</span> : { return __builtin_tgammal(__x); }</span>
<span id="L2542"><span class="lineNum"> 2542</span> : #endif</span>
<span id="L2543"><span class="lineNum"> 2543</span> : </span>
<span id="L2544"><span class="lineNum"> 2544</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT</span>
<span id="L2545"><span class="lineNum"> 2545</span> : template&lt;typename _Tp&gt;</span>
<span id="L2546"><span class="lineNum"> 2546</span> : constexpr typename __gnu_cxx::__enable_if&lt;__is_integer&lt;_Tp&gt;::__value, </span>
<span id="L2547"><span class="lineNum"> 2547</span> : double&gt;::__type</span>
<span id="L2548"><span class="lineNum"> 2548</span> : tgamma(_Tp __x)</span>
<span id="L2549"><span class="lineNum"> 2549</span> : { return __builtin_tgamma(__x); }</span>
<span id="L2550"><span class="lineNum"> 2550</span> : #endif</span>
<span id="L2551"><span class="lineNum"> 2551</span> : </span>
<span id="L2552"><span class="lineNum"> 2552</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP</span>
<span id="L2553"><span class="lineNum"> 2553</span> : constexpr float</span>
<span id="L2554"><span class="lineNum"> 2554</span> : trunc(float __x)</span>
<span id="L2555"><span class="lineNum"> 2555</span> : { return __builtin_truncf(__x); }</span>
<span id="L2556"><span class="lineNum"> 2556</span> : </span>
<span id="L2557"><span class="lineNum"> 2557</span> : constexpr long double</span>
<span id="L2558"><span class="lineNum"> 2558</span> : trunc(long double __x)</span>
<span id="L2559"><span class="lineNum"> 2559</span> : { return __builtin_truncl(__x); }</span>
<span id="L2560"><span class="lineNum"> 2560</span> : #endif</span>
<span id="L2561"><span class="lineNum"> 2561</span> : </span>
<span id="L2562"><span class="lineNum"> 2562</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT</span>
<span id="L2563"><span class="lineNum"> 2563</span> : template&lt;typename _Tp&gt;</span>
<span id="L2564"><span class="lineNum"> 2564</span> : constexpr typename __gnu_cxx::__enable_if&lt;__is_integer&lt;_Tp&gt;::__value, </span>
<span id="L2565"><span class="lineNum"> 2565</span> : double&gt;::__type</span>
<span id="L2566"><span class="lineNum"> 2566</span> : trunc(_Tp __x)</span>
<span id="L2567"><span class="lineNum"> 2567</span> : { return __builtin_trunc(__x); }</span>
<span id="L2568"><span class="lineNum"> 2568</span> : #endif</span>
<span id="L2569"><span class="lineNum"> 2569</span> : </span>
<span id="L2570"><span class="lineNum"> 2570</span> : #if defined(__STDCPP_FLOAT16_T__) &amp;&amp; defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)</span>
<span id="L2571"><span class="lineNum"> 2571</span> : constexpr _Float16</span>
<span id="L2572"><span class="lineNum"> 2572</span> : acosh(_Float16 __x)</span>
<span id="L2573"><span class="lineNum"> 2573</span> : { return _Float16(__builtin_acoshf(__x)); }</span>
<span id="L2574"><span class="lineNum"> 2574</span> : </span>
<span id="L2575"><span class="lineNum"> 2575</span> : constexpr _Float16</span>
<span id="L2576"><span class="lineNum"> 2576</span> : asinh(_Float16 __x)</span>
<span id="L2577"><span class="lineNum"> 2577</span> : { return _Float16(__builtin_asinhf(__x)); }</span>
<span id="L2578"><span class="lineNum"> 2578</span> : </span>
<span id="L2579"><span class="lineNum"> 2579</span> : constexpr _Float16</span>
<span id="L2580"><span class="lineNum"> 2580</span> : atanh(_Float16 __x)</span>
<span id="L2581"><span class="lineNum"> 2581</span> : { return _Float16(__builtin_atanhf(__x)); }</span>
<span id="L2582"><span class="lineNum"> 2582</span> : </span>
<span id="L2583"><span class="lineNum"> 2583</span> : constexpr _Float16</span>
<span id="L2584"><span class="lineNum"> 2584</span> : cbrt(_Float16 __x)</span>
<span id="L2585"><span class="lineNum"> 2585</span> : { return _Float16(__builtin_cbrtf(__x)); }</span>
<span id="L2586"><span class="lineNum"> 2586</span> : </span>
<span id="L2587"><span class="lineNum"> 2587</span> : constexpr _Float16</span>
<span id="L2588"><span class="lineNum"> 2588</span> : copysign(_Float16 __x, _Float16 __y)</span>
<span id="L2589"><span class="lineNum"> 2589</span> : { return __builtin_copysignf16(__x, __y); }</span>
<span id="L2590"><span class="lineNum"> 2590</span> : </span>
<span id="L2591"><span class="lineNum"> 2591</span> : constexpr _Float16</span>
<span id="L2592"><span class="lineNum"> 2592</span> : erf(_Float16 __x)</span>
<span id="L2593"><span class="lineNum"> 2593</span> : { return _Float16(__builtin_erff(__x)); }</span>
<span id="L2594"><span class="lineNum"> 2594</span> : </span>
<span id="L2595"><span class="lineNum"> 2595</span> : constexpr _Float16</span>
<span id="L2596"><span class="lineNum"> 2596</span> : erfc(_Float16 __x)</span>
<span id="L2597"><span class="lineNum"> 2597</span> : { return _Float16(__builtin_erfcf(__x)); }</span>
<span id="L2598"><span class="lineNum"> 2598</span> : </span>
<span id="L2599"><span class="lineNum"> 2599</span> : constexpr _Float16</span>
<span id="L2600"><span class="lineNum"> 2600</span> : exp2(_Float16 __x)</span>
<span id="L2601"><span class="lineNum"> 2601</span> : { return _Float16(__builtin_exp2f(__x)); }</span>
<span id="L2602"><span class="lineNum"> 2602</span> : </span>
<span id="L2603"><span class="lineNum"> 2603</span> : constexpr _Float16</span>
<span id="L2604"><span class="lineNum"> 2604</span> : expm1(_Float16 __x)</span>
<span id="L2605"><span class="lineNum"> 2605</span> : { return _Float16(__builtin_expm1f(__x)); }</span>
<span id="L2606"><span class="lineNum"> 2606</span> : </span>
<span id="L2607"><span class="lineNum"> 2607</span> : constexpr _Float16</span>
<span id="L2608"><span class="lineNum"> 2608</span> : fdim(_Float16 __x, _Float16 __y)</span>
<span id="L2609"><span class="lineNum"> 2609</span> : { return _Float16(__builtin_fdimf(__x, __y)); }</span>
<span id="L2610"><span class="lineNum"> 2610</span> : </span>
<span id="L2611"><span class="lineNum"> 2611</span> : constexpr _Float16</span>
<span id="L2612"><span class="lineNum"> 2612</span> : fma(_Float16 __x, _Float16 __y, _Float16 __z)</span>
<span id="L2613"><span class="lineNum"> 2613</span> : { return _Float16(__builtin_fmaf(__x, __y, __z)); }</span>
<span id="L2614"><span class="lineNum"> 2614</span> : </span>
<span id="L2615"><span class="lineNum"> 2615</span> : constexpr _Float16</span>
<span id="L2616"><span class="lineNum"> 2616</span> : fmax(_Float16 __x, _Float16 __y)</span>
<span id="L2617"><span class="lineNum"> 2617</span> : { return _Float16(__builtin_fmaxf(__x, __y)); }</span>
<span id="L2618"><span class="lineNum"> 2618</span> : </span>
<span id="L2619"><span class="lineNum"> 2619</span> : constexpr _Float16</span>
<span id="L2620"><span class="lineNum"> 2620</span> : fmin(_Float16 __x, _Float16 __y)</span>
<span id="L2621"><span class="lineNum"> 2621</span> : { return _Float16(__builtin_fminf(__x, __y)); }</span>
<span id="L2622"><span class="lineNum"> 2622</span> : </span>
<span id="L2623"><span class="lineNum"> 2623</span> : constexpr _Float16</span>
<span id="L2624"><span class="lineNum"> 2624</span> : hypot(_Float16 __x, _Float16 __y)</span>
<span id="L2625"><span class="lineNum"> 2625</span> : { return _Float16(__builtin_hypotf(__x, __y)); }</span>
<span id="L2626"><span class="lineNum"> 2626</span> : </span>
<span id="L2627"><span class="lineNum"> 2627</span> : constexpr int</span>
<span id="L2628"><span class="lineNum"> 2628</span> : ilogb(_Float16 __x)</span>
<span id="L2629"><span class="lineNum"> 2629</span> : { return _Float16(__builtin_ilogbf(__x)); }</span>
<span id="L2630"><span class="lineNum"> 2630</span> : </span>
<span id="L2631"><span class="lineNum"> 2631</span> : constexpr _Float16</span>
<span id="L2632"><span class="lineNum"> 2632</span> : lgamma(_Float16 __x)</span>
<span id="L2633"><span class="lineNum"> 2633</span> : { return _Float16(__builtin_lgammaf(__x)); }</span>
<span id="L2634"><span class="lineNum"> 2634</span> : </span>
<span id="L2635"><span class="lineNum"> 2635</span> : constexpr long long</span>
<span id="L2636"><span class="lineNum"> 2636</span> : llrint(_Float16 __x)</span>
<span id="L2637"><span class="lineNum"> 2637</span> : { return _Float16(__builtin_llrintf(__x)); }</span>
<span id="L2638"><span class="lineNum"> 2638</span> : </span>
<span id="L2639"><span class="lineNum"> 2639</span> : constexpr long long</span>
<span id="L2640"><span class="lineNum"> 2640</span> : llround(_Float16 __x)</span>
<span id="L2641"><span class="lineNum"> 2641</span> : { return _Float16(__builtin_llroundf(__x)); }</span>
<span id="L2642"><span class="lineNum"> 2642</span> : </span>
<span id="L2643"><span class="lineNum"> 2643</span> : constexpr _Float16</span>
<span id="L2644"><span class="lineNum"> 2644</span> : log1p(_Float16 __x)</span>
<span id="L2645"><span class="lineNum"> 2645</span> : { return _Float16(__builtin_log1pf(__x)); }</span>
<span id="L2646"><span class="lineNum"> 2646</span> : </span>
<span id="L2647"><span class="lineNum"> 2647</span> : // DR 568.</span>
<span id="L2648"><span class="lineNum"> 2648</span> : constexpr _Float16</span>
<span id="L2649"><span class="lineNum"> 2649</span> : log2(_Float16 __x)</span>
<span id="L2650"><span class="lineNum"> 2650</span> : { return _Float16(__builtin_log2f(__x)); }</span>
<span id="L2651"><span class="lineNum"> 2651</span> : </span>
<span id="L2652"><span class="lineNum"> 2652</span> : constexpr _Float16</span>
<span id="L2653"><span class="lineNum"> 2653</span> : logb(_Float16 __x)</span>
<span id="L2654"><span class="lineNum"> 2654</span> : { return _Float16(__builtin_logbf(__x)); }</span>
<span id="L2655"><span class="lineNum"> 2655</span> : </span>
<span id="L2656"><span class="lineNum"> 2656</span> : constexpr long</span>
<span id="L2657"><span class="lineNum"> 2657</span> : lrint(_Float16 __x)</span>
<span id="L2658"><span class="lineNum"> 2658</span> : { return _Float16(__builtin_lrintf(__x)); }</span>
<span id="L2659"><span class="lineNum"> 2659</span> : </span>
<span id="L2660"><span class="lineNum"> 2660</span> : constexpr long</span>
<span id="L2661"><span class="lineNum"> 2661</span> : lround(_Float16 __x)</span>
<span id="L2662"><span class="lineNum"> 2662</span> : { return _Float16(__builtin_lroundf(__x)); }</span>
<span id="L2663"><span class="lineNum"> 2663</span> : </span>
<span id="L2664"><span class="lineNum"> 2664</span> : constexpr _Float16</span>
<span id="L2665"><span class="lineNum"> 2665</span> : nearbyint(_Float16 __x)</span>
<span id="L2666"><span class="lineNum"> 2666</span> : { return _Float16(__builtin_nearbyintf(__x)); }</span>
<span id="L2667"><span class="lineNum"> 2667</span> : </span>
<span id="L2668"><span class="lineNum"> 2668</span> : constexpr _Float16</span>
<span id="L2669"><span class="lineNum"> 2669</span> : nextafter(_Float16 __x, _Float16 __y)</span>
<span id="L2670"><span class="lineNum"> 2670</span> : {</span>
<span id="L2671"><span class="lineNum"> 2671</span> : if (std::__is_constant_evaluated())</span>
<span id="L2672"><span class="lineNum"> 2672</span> : return __builtin_nextafterf16(__x, __y);</span>
<span id="L2673"><span class="lineNum"> 2673</span> : #ifdef __INT16_TYPE__</span>
<span id="L2674"><span class="lineNum"> 2674</span> : using __float16_int_type = __INT16_TYPE__;</span>
<span id="L2675"><span class="lineNum"> 2675</span> : #else</span>
<span id="L2676"><span class="lineNum"> 2676</span> : using __float16_int_type = short int;</span>
<span id="L2677"><span class="lineNum"> 2677</span> : #endif</span>
<span id="L2678"><span class="lineNum"> 2678</span> : __float16_int_type __hx, __hy, __ix, __iy;</span>
<span id="L2679"><span class="lineNum"> 2679</span> : __builtin_memcpy(&amp;__hx, &amp;__x, sizeof(__x));</span>
<span id="L2680"><span class="lineNum"> 2680</span> : __builtin_memcpy(&amp;__hy, &amp;__y, sizeof(__x));</span>
<span id="L2681"><span class="lineNum"> 2681</span> : __ix = __hx &amp; 0x7fff; // |x|</span>
<span id="L2682"><span class="lineNum"> 2682</span> : __iy = __hy &amp; 0x7fff; // |y|</span>
<span id="L2683"><span class="lineNum"> 2683</span> : if (__ix &gt; 0x7c00 || __iy &gt; 0x7c00) // x or y is NaN</span>
<span id="L2684"><span class="lineNum"> 2684</span> : return __x + __y;</span>
<span id="L2685"><span class="lineNum"> 2685</span> : if (__x == __y)</span>
<span id="L2686"><span class="lineNum"> 2686</span> : return __y; // x == y, return y</span>
<span id="L2687"><span class="lineNum"> 2687</span> : if (__ix == 0) // x == 0</span>
<span id="L2688"><span class="lineNum"> 2688</span> : {</span>
<span id="L2689"><span class="lineNum"> 2689</span> : __hy = (__hy &amp; 0x8000) | 1; // return +-__FLT16_DENORM_MIN__</span>
<span id="L2690"><span class="lineNum"> 2690</span> : __builtin_memcpy(&amp;__x, &amp;__hy, sizeof(__x));</span>
<span id="L2691"><span class="lineNum"> 2691</span> : __builtin_nextafterf(0.0f, 1.0f); // raise underflow</span>
<span id="L2692"><span class="lineNum"> 2692</span> : return __x;</span>
<span id="L2693"><span class="lineNum"> 2693</span> : }</span>
<span id="L2694"><span class="lineNum"> 2694</span> : if (__hx &gt;= 0) // x &gt; 0</span>
<span id="L2695"><span class="lineNum"> 2695</span> : {</span>
<span id="L2696"><span class="lineNum"> 2696</span> : if (__hx &gt; __hy) // x &gt; y, x -= ulp</span>
<span id="L2697"><span class="lineNum"> 2697</span> : --__hx;</span>
<span id="L2698"><span class="lineNum"> 2698</span> : else // x &lt; y, x += ulp</span>
<span id="L2699"><span class="lineNum"> 2699</span> : ++__hx;</span>
<span id="L2700"><span class="lineNum"> 2700</span> : }</span>
<span id="L2701"><span class="lineNum"> 2701</span> : else // x &lt; 0</span>
<span id="L2702"><span class="lineNum"> 2702</span> : {</span>
<span id="L2703"><span class="lineNum"> 2703</span> : if (__hy &gt;= 0 || __hx &gt; __hy) // x &lt; y, x -= ulp</span>
<span id="L2704"><span class="lineNum"> 2704</span> : --__hx;</span>
<span id="L2705"><span class="lineNum"> 2705</span> : else // x &gt; y, x += ulp</span>
<span id="L2706"><span class="lineNum"> 2706</span> : ++__hx;</span>
<span id="L2707"><span class="lineNum"> 2707</span> : }</span>
<span id="L2708"><span class="lineNum"> 2708</span> : __hy = __hx &amp; 0x7c00;</span>
<span id="L2709"><span class="lineNum"> 2709</span> : if (__hy &gt;= 0x7c00)</span>
<span id="L2710"><span class="lineNum"> 2710</span> : __builtin_nextafterf(__FLT_MAX__, __builtin_inff()); // overflow</span>
<span id="L2711"><span class="lineNum"> 2711</span> : else if (__hy &lt; 0x0400)</span>
<span id="L2712"><span class="lineNum"> 2712</span> : __builtin_nextafterf(__FLT_MIN__, 0.0f); // underflow</span>
<span id="L2713"><span class="lineNum"> 2713</span> : __builtin_memcpy(&amp;__x, &amp;__hx, sizeof(__x));</span>
<span id="L2714"><span class="lineNum"> 2714</span> : return __x;</span>
<span id="L2715"><span class="lineNum"> 2715</span> : }</span>
<span id="L2716"><span class="lineNum"> 2716</span> : </span>
<span id="L2717"><span class="lineNum"> 2717</span> : constexpr _Float16</span>
<span id="L2718"><span class="lineNum"> 2718</span> : remainder(_Float16 __x, _Float16 __y)</span>
<span id="L2719"><span class="lineNum"> 2719</span> : { return _Float16(__builtin_remainderf(__x, __y)); }</span>
<span id="L2720"><span class="lineNum"> 2720</span> : </span>
<span id="L2721"><span class="lineNum"> 2721</span> : inline _Float16</span>
<span id="L2722"><span class="lineNum"> 2722</span> : remquo(_Float16 __x, _Float16 __y, int* __pquo)</span>
<span id="L2723"><span class="lineNum"> 2723</span> : { return _Float16(__builtin_remquof(__x, __y, __pquo)); }</span>
<span id="L2724"><span class="lineNum"> 2724</span> : </span>
<span id="L2725"><span class="lineNum"> 2725</span> : constexpr _Float16</span>
<span id="L2726"><span class="lineNum"> 2726</span> : rint(_Float16 __x)</span>
<span id="L2727"><span class="lineNum"> 2727</span> : { return _Float16(__builtin_rintf(__x)); }</span>
<span id="L2728"><span class="lineNum"> 2728</span> : </span>
<span id="L2729"><span class="lineNum"> 2729</span> : constexpr _Float16</span>
<span id="L2730"><span class="lineNum"> 2730</span> : round(_Float16 __x)</span>
<span id="L2731"><span class="lineNum"> 2731</span> : { return _Float16(__builtin_roundf(__x)); }</span>
<span id="L2732"><span class="lineNum"> 2732</span> : </span>
<span id="L2733"><span class="lineNum"> 2733</span> : constexpr _Float16</span>
<span id="L2734"><span class="lineNum"> 2734</span> : scalbln(_Float16 __x, long __ex)</span>
<span id="L2735"><span class="lineNum"> 2735</span> : { return _Float16(__builtin_scalblnf(__x, __ex)); }</span>
<span id="L2736"><span class="lineNum"> 2736</span> : </span>
<span id="L2737"><span class="lineNum"> 2737</span> : constexpr _Float16</span>
<span id="L2738"><span class="lineNum"> 2738</span> : scalbn(_Float16 __x, int __ex)</span>
<span id="L2739"><span class="lineNum"> 2739</span> : { return _Float16(__builtin_scalbnf(__x, __ex)); }</span>
<span id="L2740"><span class="lineNum"> 2740</span> : </span>
<span id="L2741"><span class="lineNum"> 2741</span> : constexpr _Float16</span>
<span id="L2742"><span class="lineNum"> 2742</span> : tgamma(_Float16 __x)</span>
<span id="L2743"><span class="lineNum"> 2743</span> : { return _Float16(__builtin_tgammaf(__x)); }</span>
<span id="L2744"><span class="lineNum"> 2744</span> : </span>
<span id="L2745"><span class="lineNum"> 2745</span> : constexpr _Float16</span>
<span id="L2746"><span class="lineNum"> 2746</span> : trunc(_Float16 __x)</span>
<span id="L2747"><span class="lineNum"> 2747</span> : { return _Float16(__builtin_truncf(__x)); }</span>
<span id="L2748"><span class="lineNum"> 2748</span> : #endif</span>
<span id="L2749"><span class="lineNum"> 2749</span> : </span>
<span id="L2750"><span class="lineNum"> 2750</span> : #if defined(__STDCPP_FLOAT32_T__) &amp;&amp; defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)</span>
<span id="L2751"><span class="lineNum"> 2751</span> : constexpr _Float32</span>
<span id="L2752"><span class="lineNum"> 2752</span> : acosh(_Float32 __x)</span>
<span id="L2753"><span class="lineNum"> 2753</span> : { return __builtin_acoshf(__x); }</span>
<span id="L2754"><span class="lineNum"> 2754</span> : </span>
<span id="L2755"><span class="lineNum"> 2755</span> : constexpr _Float32</span>
<span id="L2756"><span class="lineNum"> 2756</span> : asinh(_Float32 __x)</span>
<span id="L2757"><span class="lineNum"> 2757</span> : { return __builtin_asinhf(__x); }</span>
<span id="L2758"><span class="lineNum"> 2758</span> : </span>
<span id="L2759"><span class="lineNum"> 2759</span> : constexpr _Float32</span>
<span id="L2760"><span class="lineNum"> 2760</span> : atanh(_Float32 __x)</span>
<span id="L2761"><span class="lineNum"> 2761</span> : { return __builtin_atanhf(__x); }</span>
<span id="L2762"><span class="lineNum"> 2762</span> : </span>
<span id="L2763"><span class="lineNum"> 2763</span> : constexpr _Float32</span>
<span id="L2764"><span class="lineNum"> 2764</span> : cbrt(_Float32 __x)</span>
<span id="L2765"><span class="lineNum"> 2765</span> : { return __builtin_cbrtf(__x); }</span>
<span id="L2766"><span class="lineNum"> 2766</span> : </span>
<span id="L2767"><span class="lineNum"> 2767</span> : constexpr _Float32</span>
<span id="L2768"><span class="lineNum"> 2768</span> : copysign(_Float32 __x, _Float32 __y)</span>
<span id="L2769"><span class="lineNum"> 2769</span> : { return __builtin_copysignf(__x, __y); }</span>
<span id="L2770"><span class="lineNum"> 2770</span> : </span>
<span id="L2771"><span class="lineNum"> 2771</span> : constexpr _Float32</span>
<span id="L2772"><span class="lineNum"> 2772</span> : erf(_Float32 __x)</span>
<span id="L2773"><span class="lineNum"> 2773</span> : { return __builtin_erff(__x); }</span>
<span id="L2774"><span class="lineNum"> 2774</span> : </span>
<span id="L2775"><span class="lineNum"> 2775</span> : constexpr _Float32</span>
<span id="L2776"><span class="lineNum"> 2776</span> : erfc(_Float32 __x)</span>
<span id="L2777"><span class="lineNum"> 2777</span> : { return __builtin_erfcf(__x); }</span>
<span id="L2778"><span class="lineNum"> 2778</span> : </span>
<span id="L2779"><span class="lineNum"> 2779</span> : constexpr _Float32</span>
<span id="L2780"><span class="lineNum"> 2780</span> : exp2(_Float32 __x)</span>
<span id="L2781"><span class="lineNum"> 2781</span> : { return __builtin_exp2f(__x); }</span>
<span id="L2782"><span class="lineNum"> 2782</span> : </span>
<span id="L2783"><span class="lineNum"> 2783</span> : constexpr _Float32</span>
<span id="L2784"><span class="lineNum"> 2784</span> : expm1(_Float32 __x)</span>
<span id="L2785"><span class="lineNum"> 2785</span> : { return __builtin_expm1f(__x); }</span>
<span id="L2786"><span class="lineNum"> 2786</span> : </span>
<span id="L2787"><span class="lineNum"> 2787</span> : constexpr _Float32</span>
<span id="L2788"><span class="lineNum"> 2788</span> : fdim(_Float32 __x, _Float32 __y)</span>
<span id="L2789"><span class="lineNum"> 2789</span> : { return __builtin_fdimf(__x, __y); }</span>
<span id="L2790"><span class="lineNum"> 2790</span> : </span>
<span id="L2791"><span class="lineNum"> 2791</span> : constexpr _Float32</span>
<span id="L2792"><span class="lineNum"> 2792</span> : fma(_Float32 __x, _Float32 __y, _Float32 __z)</span>
<span id="L2793"><span class="lineNum"> 2793</span> : { return __builtin_fmaf(__x, __y, __z); }</span>
<span id="L2794"><span class="lineNum"> 2794</span> : </span>
<span id="L2795"><span class="lineNum"> 2795</span> : constexpr _Float32</span>
<span id="L2796"><span class="lineNum"> 2796</span> : fmax(_Float32 __x, _Float32 __y)</span>
<span id="L2797"><span class="lineNum"> 2797</span> : { return __builtin_fmaxf(__x, __y); }</span>
<span id="L2798"><span class="lineNum"> 2798</span> : </span>
<span id="L2799"><span class="lineNum"> 2799</span> : constexpr _Float32</span>
<span id="L2800"><span class="lineNum"> 2800</span> : fmin(_Float32 __x, _Float32 __y)</span>
<span id="L2801"><span class="lineNum"> 2801</span> : { return __builtin_fminf(__x, __y); }</span>
<span id="L2802"><span class="lineNum"> 2802</span> : </span>
<span id="L2803"><span class="lineNum"> 2803</span> : constexpr _Float32</span>
<span id="L2804"><span class="lineNum"> 2804</span> : hypot(_Float32 __x, _Float32 __y)</span>
<span id="L2805"><span class="lineNum"> 2805</span> : { return __builtin_hypotf(__x, __y); }</span>
<span id="L2806"><span class="lineNum"> 2806</span> : </span>
<span id="L2807"><span class="lineNum"> 2807</span> : constexpr int</span>
<span id="L2808"><span class="lineNum"> 2808</span> : ilogb(_Float32 __x)</span>
<span id="L2809"><span class="lineNum"> 2809</span> : { return __builtin_ilogbf(__x); }</span>
<span id="L2810"><span class="lineNum"> 2810</span> : </span>
<span id="L2811"><span class="lineNum"> 2811</span> : constexpr _Float32</span>
<span id="L2812"><span class="lineNum"> 2812</span> : lgamma(_Float32 __x)</span>
<span id="L2813"><span class="lineNum"> 2813</span> : { return __builtin_lgammaf(__x); }</span>
<span id="L2814"><span class="lineNum"> 2814</span> : </span>
<span id="L2815"><span class="lineNum"> 2815</span> : constexpr long long</span>
<span id="L2816"><span class="lineNum"> 2816</span> : llrint(_Float32 __x)</span>
<span id="L2817"><span class="lineNum"> 2817</span> : { return __builtin_llrintf(__x); }</span>
<span id="L2818"><span class="lineNum"> 2818</span> : </span>
<span id="L2819"><span class="lineNum"> 2819</span> : constexpr long long</span>
<span id="L2820"><span class="lineNum"> 2820</span> : llround(_Float32 __x)</span>
<span id="L2821"><span class="lineNum"> 2821</span> : { return __builtin_llroundf(__x); }</span>
<span id="L2822"><span class="lineNum"> 2822</span> : </span>
<span id="L2823"><span class="lineNum"> 2823</span> : constexpr _Float32</span>
<span id="L2824"><span class="lineNum"> 2824</span> : log1p(_Float32 __x)</span>
<span id="L2825"><span class="lineNum"> 2825</span> : { return __builtin_log1pf(__x); }</span>
<span id="L2826"><span class="lineNum"> 2826</span> : </span>
<span id="L2827"><span class="lineNum"> 2827</span> : // DR 568.</span>
<span id="L2828"><span class="lineNum"> 2828</span> : constexpr _Float32</span>
<span id="L2829"><span class="lineNum"> 2829</span> : log2(_Float32 __x)</span>
<span id="L2830"><span class="lineNum"> 2830</span> : { return __builtin_log2f(__x); }</span>
<span id="L2831"><span class="lineNum"> 2831</span> : </span>
<span id="L2832"><span class="lineNum"> 2832</span> : constexpr _Float32</span>
<span id="L2833"><span class="lineNum"> 2833</span> : logb(_Float32 __x)</span>
<span id="L2834"><span class="lineNum"> 2834</span> : { return __builtin_logbf(__x); }</span>
<span id="L2835"><span class="lineNum"> 2835</span> : </span>
<span id="L2836"><span class="lineNum"> 2836</span> : constexpr long</span>
<span id="L2837"><span class="lineNum"> 2837</span> : lrint(_Float32 __x)</span>
<span id="L2838"><span class="lineNum"> 2838</span> : { return __builtin_lrintf(__x); }</span>
<span id="L2839"><span class="lineNum"> 2839</span> : </span>
<span id="L2840"><span class="lineNum"> 2840</span> : constexpr long</span>
<span id="L2841"><span class="lineNum"> 2841</span> : lround(_Float32 __x)</span>
<span id="L2842"><span class="lineNum"> 2842</span> : { return __builtin_lroundf(__x); }</span>
<span id="L2843"><span class="lineNum"> 2843</span> : </span>
<span id="L2844"><span class="lineNum"> 2844</span> : constexpr _Float32</span>
<span id="L2845"><span class="lineNum"> 2845</span> : nearbyint(_Float32 __x)</span>
<span id="L2846"><span class="lineNum"> 2846</span> : { return __builtin_nearbyintf(__x); }</span>
<span id="L2847"><span class="lineNum"> 2847</span> : </span>
<span id="L2848"><span class="lineNum"> 2848</span> : constexpr _Float32</span>
<span id="L2849"><span class="lineNum"> 2849</span> : nextafter(_Float32 __x, _Float32 __y)</span>
<span id="L2850"><span class="lineNum"> 2850</span> : { return __builtin_nextafterf(__x, __y); }</span>
<span id="L2851"><span class="lineNum"> 2851</span> : </span>
<span id="L2852"><span class="lineNum"> 2852</span> : constexpr _Float32</span>
<span id="L2853"><span class="lineNum"> 2853</span> : remainder(_Float32 __x, _Float32 __y)</span>
<span id="L2854"><span class="lineNum"> 2854</span> : { return __builtin_remainderf(__x, __y); }</span>
<span id="L2855"><span class="lineNum"> 2855</span> : </span>
<span id="L2856"><span class="lineNum"> 2856</span> : inline _Float32</span>
<span id="L2857"><span class="lineNum"> 2857</span> : remquo(_Float32 __x, _Float32 __y, int* __pquo)</span>
<span id="L2858"><span class="lineNum"> 2858</span> : { return __builtin_remquof(__x, __y, __pquo); }</span>
<span id="L2859"><span class="lineNum"> 2859</span> : </span>
<span id="L2860"><span class="lineNum"> 2860</span> : constexpr _Float32</span>
<span id="L2861"><span class="lineNum"> 2861</span> : rint(_Float32 __x)</span>
<span id="L2862"><span class="lineNum"> 2862</span> : { return __builtin_rintf(__x); }</span>
<span id="L2863"><span class="lineNum"> 2863</span> : </span>
<span id="L2864"><span class="lineNum"> 2864</span> : constexpr _Float32</span>
<span id="L2865"><span class="lineNum"> 2865</span> : round(_Float32 __x)</span>
<span id="L2866"><span class="lineNum"> 2866</span> : { return __builtin_roundf(__x); }</span>
<span id="L2867"><span class="lineNum"> 2867</span> : </span>
<span id="L2868"><span class="lineNum"> 2868</span> : constexpr _Float32</span>
<span id="L2869"><span class="lineNum"> 2869</span> : scalbln(_Float32 __x, long __ex)</span>
<span id="L2870"><span class="lineNum"> 2870</span> : { return __builtin_scalblnf(__x, __ex); }</span>
<span id="L2871"><span class="lineNum"> 2871</span> : </span>
<span id="L2872"><span class="lineNum"> 2872</span> : constexpr _Float32</span>
<span id="L2873"><span class="lineNum"> 2873</span> : scalbn(_Float32 __x, int __ex)</span>
<span id="L2874"><span class="lineNum"> 2874</span> : { return __builtin_scalbnf(__x, __ex); }</span>
<span id="L2875"><span class="lineNum"> 2875</span> : </span>
<span id="L2876"><span class="lineNum"> 2876</span> : constexpr _Float32</span>
<span id="L2877"><span class="lineNum"> 2877</span> : tgamma(_Float32 __x)</span>
<span id="L2878"><span class="lineNum"> 2878</span> : { return __builtin_tgammaf(__x); }</span>
<span id="L2879"><span class="lineNum"> 2879</span> : </span>
<span id="L2880"><span class="lineNum"> 2880</span> : constexpr _Float32</span>
<span id="L2881"><span class="lineNum"> 2881</span> : trunc(_Float32 __x)</span>
<span id="L2882"><span class="lineNum"> 2882</span> : { return __builtin_truncf(__x); }</span>
<span id="L2883"><span class="lineNum"> 2883</span> : #endif</span>
<span id="L2884"><span class="lineNum"> 2884</span> : </span>
<span id="L2885"><span class="lineNum"> 2885</span> : #if defined(__STDCPP_FLOAT64_T__) &amp;&amp; defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)</span>
<span id="L2886"><span class="lineNum"> 2886</span> : constexpr _Float64</span>
<span id="L2887"><span class="lineNum"> 2887</span> : acosh(_Float64 __x)</span>
<span id="L2888"><span class="lineNum"> 2888</span> : { return __builtin_acosh(__x); }</span>
<span id="L2889"><span class="lineNum"> 2889</span> : </span>
<span id="L2890"><span class="lineNum"> 2890</span> : constexpr _Float64</span>
<span id="L2891"><span class="lineNum"> 2891</span> : asinh(_Float64 __x)</span>
<span id="L2892"><span class="lineNum"> 2892</span> : { return __builtin_asinh(__x); }</span>
<span id="L2893"><span class="lineNum"> 2893</span> : </span>
<span id="L2894"><span class="lineNum"> 2894</span> : constexpr _Float64</span>
<span id="L2895"><span class="lineNum"> 2895</span> : atanh(_Float64 __x)</span>
<span id="L2896"><span class="lineNum"> 2896</span> : { return __builtin_atanh(__x); }</span>
<span id="L2897"><span class="lineNum"> 2897</span> : </span>
<span id="L2898"><span class="lineNum"> 2898</span> : constexpr _Float64</span>
<span id="L2899"><span class="lineNum"> 2899</span> : cbrt(_Float64 __x)</span>
<span id="L2900"><span class="lineNum"> 2900</span> : { return __builtin_cbrt(__x); }</span>
<span id="L2901"><span class="lineNum"> 2901</span> : </span>
<span id="L2902"><span class="lineNum"> 2902</span> : constexpr _Float64</span>
<span id="L2903"><span class="lineNum"> 2903</span> : copysign(_Float64 __x, _Float64 __y)</span>
<span id="L2904"><span class="lineNum"> 2904</span> : { return __builtin_copysign(__x, __y); }</span>
<span id="L2905"><span class="lineNum"> 2905</span> : </span>
<span id="L2906"><span class="lineNum"> 2906</span> : constexpr _Float64</span>
<span id="L2907"><span class="lineNum"> 2907</span> : erf(_Float64 __x)</span>
<span id="L2908"><span class="lineNum"> 2908</span> : { return __builtin_erf(__x); }</span>
<span id="L2909"><span class="lineNum"> 2909</span> : </span>
<span id="L2910"><span class="lineNum"> 2910</span> : constexpr _Float64</span>
<span id="L2911"><span class="lineNum"> 2911</span> : erfc(_Float64 __x)</span>
<span id="L2912"><span class="lineNum"> 2912</span> : { return __builtin_erfc(__x); }</span>
<span id="L2913"><span class="lineNum"> 2913</span> : </span>
<span id="L2914"><span class="lineNum"> 2914</span> : constexpr _Float64</span>
<span id="L2915"><span class="lineNum"> 2915</span> : exp2(_Float64 __x)</span>
<span id="L2916"><span class="lineNum"> 2916</span> : { return __builtin_exp2(__x); }</span>
<span id="L2917"><span class="lineNum"> 2917</span> : </span>
<span id="L2918"><span class="lineNum"> 2918</span> : constexpr _Float64</span>
<span id="L2919"><span class="lineNum"> 2919</span> : expm1(_Float64 __x)</span>
<span id="L2920"><span class="lineNum"> 2920</span> : { return __builtin_expm1(__x); }</span>
<span id="L2921"><span class="lineNum"> 2921</span> : </span>
<span id="L2922"><span class="lineNum"> 2922</span> : constexpr _Float64</span>
<span id="L2923"><span class="lineNum"> 2923</span> : fdim(_Float64 __x, _Float64 __y)</span>
<span id="L2924"><span class="lineNum"> 2924</span> : { return __builtin_fdim(__x, __y); }</span>
<span id="L2925"><span class="lineNum"> 2925</span> : </span>
<span id="L2926"><span class="lineNum"> 2926</span> : constexpr _Float64</span>
<span id="L2927"><span class="lineNum"> 2927</span> : fma(_Float64 __x, _Float64 __y, _Float64 __z)</span>
<span id="L2928"><span class="lineNum"> 2928</span> : { return __builtin_fma(__x, __y, __z); }</span>
<span id="L2929"><span class="lineNum"> 2929</span> : </span>
<span id="L2930"><span class="lineNum"> 2930</span> : constexpr _Float64</span>
<span id="L2931"><span class="lineNum"> 2931</span> : fmax(_Float64 __x, _Float64 __y)</span>
<span id="L2932"><span class="lineNum"> 2932</span> : { return __builtin_fmax(__x, __y); }</span>
<span id="L2933"><span class="lineNum"> 2933</span> : </span>
<span id="L2934"><span class="lineNum"> 2934</span> : constexpr _Float64</span>
<span id="L2935"><span class="lineNum"> 2935</span> : fmin(_Float64 __x, _Float64 __y)</span>
<span id="L2936"><span class="lineNum"> 2936</span> : { return __builtin_fmin(__x, __y); }</span>
<span id="L2937"><span class="lineNum"> 2937</span> : </span>
<span id="L2938"><span class="lineNum"> 2938</span> : constexpr _Float64</span>
<span id="L2939"><span class="lineNum"> 2939</span> : hypot(_Float64 __x, _Float64 __y)</span>
<span id="L2940"><span class="lineNum"> 2940</span> : { return __builtin_hypot(__x, __y); }</span>
<span id="L2941"><span class="lineNum"> 2941</span> : </span>
<span id="L2942"><span class="lineNum"> 2942</span> : constexpr int</span>
<span id="L2943"><span class="lineNum"> 2943</span> : ilogb(_Float64 __x)</span>
<span id="L2944"><span class="lineNum"> 2944</span> : { return __builtin_ilogb(__x); }</span>
<span id="L2945"><span class="lineNum"> 2945</span> : </span>
<span id="L2946"><span class="lineNum"> 2946</span> : constexpr _Float64</span>
<span id="L2947"><span class="lineNum"> 2947</span> : lgamma(_Float64 __x)</span>
<span id="L2948"><span class="lineNum"> 2948</span> : { return __builtin_lgamma(__x); }</span>
<span id="L2949"><span class="lineNum"> 2949</span> : </span>
<span id="L2950"><span class="lineNum"> 2950</span> : constexpr long long</span>
<span id="L2951"><span class="lineNum"> 2951</span> : llrint(_Float64 __x)</span>
<span id="L2952"><span class="lineNum"> 2952</span> : { return __builtin_llrint(__x); }</span>
<span id="L2953"><span class="lineNum"> 2953</span> : </span>
<span id="L2954"><span class="lineNum"> 2954</span> : constexpr long long</span>
<span id="L2955"><span class="lineNum"> 2955</span> : llround(_Float64 __x)</span>
<span id="L2956"><span class="lineNum"> 2956</span> : { return __builtin_llround(__x); }</span>
<span id="L2957"><span class="lineNum"> 2957</span> : </span>
<span id="L2958"><span class="lineNum"> 2958</span> : constexpr _Float64</span>
<span id="L2959"><span class="lineNum"> 2959</span> : log1p(_Float64 __x)</span>
<span id="L2960"><span class="lineNum"> 2960</span> : { return __builtin_log1p(__x); }</span>
<span id="L2961"><span class="lineNum"> 2961</span> : </span>
<span id="L2962"><span class="lineNum"> 2962</span> : // DR 568.</span>
<span id="L2963"><span class="lineNum"> 2963</span> : constexpr _Float64</span>
<span id="L2964"><span class="lineNum"> 2964</span> : log2(_Float64 __x)</span>
<span id="L2965"><span class="lineNum"> 2965</span> : { return __builtin_log2(__x); }</span>
<span id="L2966"><span class="lineNum"> 2966</span> : </span>
<span id="L2967"><span class="lineNum"> 2967</span> : constexpr _Float64</span>
<span id="L2968"><span class="lineNum"> 2968</span> : logb(_Float64 __x)</span>
<span id="L2969"><span class="lineNum"> 2969</span> : { return __builtin_logb(__x); }</span>
<span id="L2970"><span class="lineNum"> 2970</span> : </span>
<span id="L2971"><span class="lineNum"> 2971</span> : constexpr long</span>
<span id="L2972"><span class="lineNum"> 2972</span> : lrint(_Float64 __x)</span>
<span id="L2973"><span class="lineNum"> 2973</span> : { return __builtin_lrint(__x); }</span>
<span id="L2974"><span class="lineNum"> 2974</span> : </span>
<span id="L2975"><span class="lineNum"> 2975</span> : constexpr long</span>
<span id="L2976"><span class="lineNum"> 2976</span> : lround(_Float64 __x)</span>
<span id="L2977"><span class="lineNum"> 2977</span> : { return __builtin_lround(__x); }</span>
<span id="L2978"><span class="lineNum"> 2978</span> : </span>
<span id="L2979"><span class="lineNum"> 2979</span> : constexpr _Float64</span>
<span id="L2980"><span class="lineNum"> 2980</span> : nearbyint(_Float64 __x)</span>
<span id="L2981"><span class="lineNum"> 2981</span> : { return __builtin_nearbyint(__x); }</span>
<span id="L2982"><span class="lineNum"> 2982</span> : </span>
<span id="L2983"><span class="lineNum"> 2983</span> : constexpr _Float64</span>
<span id="L2984"><span class="lineNum"> 2984</span> : nextafter(_Float64 __x, _Float64 __y)</span>
<span id="L2985"><span class="lineNum"> 2985</span> : { return __builtin_nextafter(__x, __y); }</span>
<span id="L2986"><span class="lineNum"> 2986</span> : </span>
<span id="L2987"><span class="lineNum"> 2987</span> : constexpr _Float64</span>
<span id="L2988"><span class="lineNum"> 2988</span> : remainder(_Float64 __x, _Float64 __y)</span>
<span id="L2989"><span class="lineNum"> 2989</span> : { return __builtin_remainder(__x, __y); }</span>
<span id="L2990"><span class="lineNum"> 2990</span> : </span>
<span id="L2991"><span class="lineNum"> 2991</span> : inline _Float64</span>
<span id="L2992"><span class="lineNum"> 2992</span> : remquo(_Float64 __x, _Float64 __y, int* __pquo)</span>
<span id="L2993"><span class="lineNum"> 2993</span> : { return __builtin_remquo(__x, __y, __pquo); }</span>
<span id="L2994"><span class="lineNum"> 2994</span> : </span>
<span id="L2995"><span class="lineNum"> 2995</span> : constexpr _Float64</span>
<span id="L2996"><span class="lineNum"> 2996</span> : rint(_Float64 __x)</span>
<span id="L2997"><span class="lineNum"> 2997</span> : { return __builtin_rint(__x); }</span>
<span id="L2998"><span class="lineNum"> 2998</span> : </span>
<span id="L2999"><span class="lineNum"> 2999</span> : constexpr _Float64</span>
<span id="L3000"><span class="lineNum"> 3000</span> : round(_Float64 __x)</span>
<span id="L3001"><span class="lineNum"> 3001</span> : { return __builtin_round(__x); }</span>
<span id="L3002"><span class="lineNum"> 3002</span> : </span>
<span id="L3003"><span class="lineNum"> 3003</span> : constexpr _Float64</span>
<span id="L3004"><span class="lineNum"> 3004</span> : scalbln(_Float64 __x, long __ex)</span>
<span id="L3005"><span class="lineNum"> 3005</span> : { return __builtin_scalbln(__x, __ex); }</span>
<span id="L3006"><span class="lineNum"> 3006</span> : </span>
<span id="L3007"><span class="lineNum"> 3007</span> : constexpr _Float64</span>
<span id="L3008"><span class="lineNum"> 3008</span> : scalbn(_Float64 __x, int __ex)</span>
<span id="L3009"><span class="lineNum"> 3009</span> : { return __builtin_scalbn(__x, __ex); }</span>
<span id="L3010"><span class="lineNum"> 3010</span> : </span>
<span id="L3011"><span class="lineNum"> 3011</span> : constexpr _Float64</span>
<span id="L3012"><span class="lineNum"> 3012</span> : tgamma(_Float64 __x)</span>
<span id="L3013"><span class="lineNum"> 3013</span> : { return __builtin_tgamma(__x); }</span>
<span id="L3014"><span class="lineNum"> 3014</span> : </span>
<span id="L3015"><span class="lineNum"> 3015</span> : constexpr _Float64</span>
<span id="L3016"><span class="lineNum"> 3016</span> : trunc(_Float64 __x)</span>
<span id="L3017"><span class="lineNum"> 3017</span> : { return __builtin_trunc(__x); }</span>
<span id="L3018"><span class="lineNum"> 3018</span> : #endif</span>
<span id="L3019"><span class="lineNum"> 3019</span> : </span>
<span id="L3020"><span class="lineNum"> 3020</span> : #if defined(__STDCPP_FLOAT128_T__) &amp;&amp; defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128)</span>
<span id="L3021"><span class="lineNum"> 3021</span> : constexpr _Float128</span>
<span id="L3022"><span class="lineNum"> 3022</span> : acosh(_Float128 __x)</span>
<span id="L3023"><span class="lineNum"> 3023</span> : { return __builtin_acoshl(__x); }</span>
<span id="L3024"><span class="lineNum"> 3024</span> : </span>
<span id="L3025"><span class="lineNum"> 3025</span> : constexpr _Float128</span>
<span id="L3026"><span class="lineNum"> 3026</span> : asinh(_Float128 __x)</span>
<span id="L3027"><span class="lineNum"> 3027</span> : { return __builtin_asinhl(__x); }</span>
<span id="L3028"><span class="lineNum"> 3028</span> : </span>
<span id="L3029"><span class="lineNum"> 3029</span> : constexpr _Float128</span>
<span id="L3030"><span class="lineNum"> 3030</span> : atanh(_Float128 __x)</span>
<span id="L3031"><span class="lineNum"> 3031</span> : { return __builtin_atanhl(__x); }</span>
<span id="L3032"><span class="lineNum"> 3032</span> : </span>
<span id="L3033"><span class="lineNum"> 3033</span> : constexpr _Float128</span>
<span id="L3034"><span class="lineNum"> 3034</span> : cbrt(_Float128 __x)</span>
<span id="L3035"><span class="lineNum"> 3035</span> : { return __builtin_cbrtl(__x); }</span>
<span id="L3036"><span class="lineNum"> 3036</span> : </span>
<span id="L3037"><span class="lineNum"> 3037</span> : constexpr _Float128</span>
<span id="L3038"><span class="lineNum"> 3038</span> : copysign(_Float128 __x, _Float128 __y)</span>
<span id="L3039"><span class="lineNum"> 3039</span> : { return __builtin_copysignl(__x, __y); }</span>
<span id="L3040"><span class="lineNum"> 3040</span> : </span>
<span id="L3041"><span class="lineNum"> 3041</span> : constexpr _Float128</span>
<span id="L3042"><span class="lineNum"> 3042</span> : erf(_Float128 __x)</span>
<span id="L3043"><span class="lineNum"> 3043</span> : { return __builtin_erfl(__x); }</span>
<span id="L3044"><span class="lineNum"> 3044</span> : </span>
<span id="L3045"><span class="lineNum"> 3045</span> : constexpr _Float128</span>
<span id="L3046"><span class="lineNum"> 3046</span> : erfc(_Float128 __x)</span>
<span id="L3047"><span class="lineNum"> 3047</span> : { return __builtin_erfcl(__x); }</span>
<span id="L3048"><span class="lineNum"> 3048</span> : </span>
<span id="L3049"><span class="lineNum"> 3049</span> : constexpr _Float128</span>
<span id="L3050"><span class="lineNum"> 3050</span> : exp2(_Float128 __x)</span>
<span id="L3051"><span class="lineNum"> 3051</span> : { return __builtin_exp2l(__x); }</span>
<span id="L3052"><span class="lineNum"> 3052</span> : </span>
<span id="L3053"><span class="lineNum"> 3053</span> : constexpr _Float128</span>
<span id="L3054"><span class="lineNum"> 3054</span> : expm1(_Float128 __x)</span>
<span id="L3055"><span class="lineNum"> 3055</span> : { return __builtin_expm1l(__x); }</span>
<span id="L3056"><span class="lineNum"> 3056</span> : </span>
<span id="L3057"><span class="lineNum"> 3057</span> : constexpr _Float128</span>
<span id="L3058"><span class="lineNum"> 3058</span> : fdim(_Float128 __x, _Float128 __y)</span>
<span id="L3059"><span class="lineNum"> 3059</span> : { return __builtin_fdiml(__x, __y); }</span>
<span id="L3060"><span class="lineNum"> 3060</span> : </span>
<span id="L3061"><span class="lineNum"> 3061</span> : constexpr _Float128</span>
<span id="L3062"><span class="lineNum"> 3062</span> : fma(_Float128 __x, _Float128 __y, _Float128 __z)</span>
<span id="L3063"><span class="lineNum"> 3063</span> : { return __builtin_fmal(__x, __y, __z); }</span>
<span id="L3064"><span class="lineNum"> 3064</span> : </span>
<span id="L3065"><span class="lineNum"> 3065</span> : constexpr _Float128</span>
<span id="L3066"><span class="lineNum"> 3066</span> : fmax(_Float128 __x, _Float128 __y)</span>
<span id="L3067"><span class="lineNum"> 3067</span> : { return __builtin_fmaxl(__x, __y); }</span>
<span id="L3068"><span class="lineNum"> 3068</span> : </span>
<span id="L3069"><span class="lineNum"> 3069</span> : constexpr _Float128</span>
<span id="L3070"><span class="lineNum"> 3070</span> : fmin(_Float128 __x, _Float128 __y)</span>
<span id="L3071"><span class="lineNum"> 3071</span> : { return __builtin_fminl(__x, __y); }</span>
<span id="L3072"><span class="lineNum"> 3072</span> : </span>
<span id="L3073"><span class="lineNum"> 3073</span> : constexpr _Float128</span>
<span id="L3074"><span class="lineNum"> 3074</span> : hypot(_Float128 __x, _Float128 __y)</span>
<span id="L3075"><span class="lineNum"> 3075</span> : { return __builtin_hypotl(__x, __y); }</span>
<span id="L3076"><span class="lineNum"> 3076</span> : </span>
<span id="L3077"><span class="lineNum"> 3077</span> : constexpr int</span>
<span id="L3078"><span class="lineNum"> 3078</span> : ilogb(_Float128 __x)</span>
<span id="L3079"><span class="lineNum"> 3079</span> : { return __builtin_ilogbl(__x); }</span>
<span id="L3080"><span class="lineNum"> 3080</span> : </span>
<span id="L3081"><span class="lineNum"> 3081</span> : constexpr _Float128</span>
<span id="L3082"><span class="lineNum"> 3082</span> : lgamma(_Float128 __x)</span>
<span id="L3083"><span class="lineNum"> 3083</span> : { return __builtin_lgammal(__x); }</span>
<span id="L3084"><span class="lineNum"> 3084</span> : </span>
<span id="L3085"><span class="lineNum"> 3085</span> : constexpr long long</span>
<span id="L3086"><span class="lineNum"> 3086</span> : llrint(_Float128 __x)</span>
<span id="L3087"><span class="lineNum"> 3087</span> : { return __builtin_llrintl(__x); }</span>
<span id="L3088"><span class="lineNum"> 3088</span> : </span>
<span id="L3089"><span class="lineNum"> 3089</span> : constexpr long long</span>
<span id="L3090"><span class="lineNum"> 3090</span> : llround(_Float128 __x)</span>
<span id="L3091"><span class="lineNum"> 3091</span> : { return __builtin_llroundl(__x); }</span>
<span id="L3092"><span class="lineNum"> 3092</span> : </span>
<span id="L3093"><span class="lineNum"> 3093</span> : constexpr _Float128</span>
<span id="L3094"><span class="lineNum"> 3094</span> : log1p(_Float128 __x)</span>
<span id="L3095"><span class="lineNum"> 3095</span> : { return __builtin_log1pl(__x); }</span>
<span id="L3096"><span class="lineNum"> 3096</span> : </span>
<span id="L3097"><span class="lineNum"> 3097</span> : // DR 568.</span>
<span id="L3098"><span class="lineNum"> 3098</span> : constexpr _Float128</span>
<span id="L3099"><span class="lineNum"> 3099</span> : log2(_Float128 __x)</span>
<span id="L3100"><span class="lineNum"> 3100</span> : { return __builtin_log2l(__x); }</span>
<span id="L3101"><span class="lineNum"> 3101</span> : </span>
<span id="L3102"><span class="lineNum"> 3102</span> : constexpr _Float128</span>
<span id="L3103"><span class="lineNum"> 3103</span> : logb(_Float128 __x)</span>
<span id="L3104"><span class="lineNum"> 3104</span> : { return __builtin_logbl(__x); }</span>
<span id="L3105"><span class="lineNum"> 3105</span> : </span>
<span id="L3106"><span class="lineNum"> 3106</span> : constexpr long</span>
<span id="L3107"><span class="lineNum"> 3107</span> : lrint(_Float128 __x)</span>
<span id="L3108"><span class="lineNum"> 3108</span> : { return __builtin_lrintl(__x); }</span>
<span id="L3109"><span class="lineNum"> 3109</span> : </span>
<span id="L3110"><span class="lineNum"> 3110</span> : constexpr long</span>
<span id="L3111"><span class="lineNum"> 3111</span> : lround(_Float128 __x)</span>
<span id="L3112"><span class="lineNum"> 3112</span> : { return __builtin_lroundl(__x); }</span>
<span id="L3113"><span class="lineNum"> 3113</span> : </span>
<span id="L3114"><span class="lineNum"> 3114</span> : constexpr _Float128</span>
<span id="L3115"><span class="lineNum"> 3115</span> : nearbyint(_Float128 __x)</span>
<span id="L3116"><span class="lineNum"> 3116</span> : { return __builtin_nearbyintl(__x); }</span>
<span id="L3117"><span class="lineNum"> 3117</span> : </span>
<span id="L3118"><span class="lineNum"> 3118</span> : constexpr _Float128</span>
<span id="L3119"><span class="lineNum"> 3119</span> : nextafter(_Float128 __x, _Float128 __y)</span>
<span id="L3120"><span class="lineNum"> 3120</span> : { return __builtin_nextafterl(__x, __y); }</span>
<span id="L3121"><span class="lineNum"> 3121</span> : </span>
<span id="L3122"><span class="lineNum"> 3122</span> : constexpr _Float128</span>
<span id="L3123"><span class="lineNum"> 3123</span> : remainder(_Float128 __x, _Float128 __y)</span>
<span id="L3124"><span class="lineNum"> 3124</span> : { return __builtin_remainderl(__x, __y); }</span>
<span id="L3125"><span class="lineNum"> 3125</span> : </span>
<span id="L3126"><span class="lineNum"> 3126</span> : inline _Float128</span>
<span id="L3127"><span class="lineNum"> 3127</span> : remquo(_Float128 __x, _Float128 __y, int* __pquo)</span>
<span id="L3128"><span class="lineNum"> 3128</span> : { return __builtin_remquol(__x, __y, __pquo); }</span>
<span id="L3129"><span class="lineNum"> 3129</span> : </span>
<span id="L3130"><span class="lineNum"> 3130</span> : constexpr _Float128</span>
<span id="L3131"><span class="lineNum"> 3131</span> : rint(_Float128 __x)</span>
<span id="L3132"><span class="lineNum"> 3132</span> : { return __builtin_rintl(__x); }</span>
<span id="L3133"><span class="lineNum"> 3133</span> : </span>
<span id="L3134"><span class="lineNum"> 3134</span> : constexpr _Float128</span>
<span id="L3135"><span class="lineNum"> 3135</span> : round(_Float128 __x)</span>
<span id="L3136"><span class="lineNum"> 3136</span> : { return __builtin_roundl(__x); }</span>
<span id="L3137"><span class="lineNum"> 3137</span> : </span>
<span id="L3138"><span class="lineNum"> 3138</span> : constexpr _Float128</span>
<span id="L3139"><span class="lineNum"> 3139</span> : scalbln(_Float128 __x, long __ex)</span>
<span id="L3140"><span class="lineNum"> 3140</span> : { return __builtin_scalblnl(__x, __ex); }</span>
<span id="L3141"><span class="lineNum"> 3141</span> : </span>
<span id="L3142"><span class="lineNum"> 3142</span> : constexpr _Float128</span>
<span id="L3143"><span class="lineNum"> 3143</span> : scalbn(_Float128 __x, int __ex)</span>
<span id="L3144"><span class="lineNum"> 3144</span> : { return __builtin_scalbnl(__x, __ex); }</span>
<span id="L3145"><span class="lineNum"> 3145</span> : </span>
<span id="L3146"><span class="lineNum"> 3146</span> : constexpr _Float128</span>
<span id="L3147"><span class="lineNum"> 3147</span> : tgamma(_Float128 __x)</span>
<span id="L3148"><span class="lineNum"> 3148</span> : { return __builtin_tgammal(__x); }</span>
<span id="L3149"><span class="lineNum"> 3149</span> : </span>
<span id="L3150"><span class="lineNum"> 3150</span> : constexpr _Float128</span>
<span id="L3151"><span class="lineNum"> 3151</span> : trunc(_Float128 __x)</span>
<span id="L3152"><span class="lineNum"> 3152</span> : { return __builtin_truncl(__x); }</span>
<span id="L3153"><span class="lineNum"> 3153</span> : #elif defined(__STDCPP_FLOAT128_T__) &amp;&amp; defined(_GLIBCXX_HAVE_FLOAT128_MATH)</span>
<span id="L3154"><span class="lineNum"> 3154</span> : constexpr _Float128</span>
<span id="L3155"><span class="lineNum"> 3155</span> : acosh(_Float128 __x)</span>
<span id="L3156"><span class="lineNum"> 3156</span> : { return __builtin_acoshf128(__x); }</span>
<span id="L3157"><span class="lineNum"> 3157</span> : </span>
<span id="L3158"><span class="lineNum"> 3158</span> : constexpr _Float128</span>
<span id="L3159"><span class="lineNum"> 3159</span> : asinh(_Float128 __x)</span>
<span id="L3160"><span class="lineNum"> 3160</span> : { return __builtin_asinhf128(__x); }</span>
<span id="L3161"><span class="lineNum"> 3161</span> : </span>
<span id="L3162"><span class="lineNum"> 3162</span> : constexpr _Float128</span>
<span id="L3163"><span class="lineNum"> 3163</span> : atanh(_Float128 __x)</span>
<span id="L3164"><span class="lineNum"> 3164</span> : { return __builtin_atanhf128(__x); }</span>
<span id="L3165"><span class="lineNum"> 3165</span> : </span>
<span id="L3166"><span class="lineNum"> 3166</span> : constexpr _Float128</span>
<span id="L3167"><span class="lineNum"> 3167</span> : cbrt(_Float128 __x)</span>
<span id="L3168"><span class="lineNum"> 3168</span> : { return __builtin_cbrtf128(__x); }</span>
<span id="L3169"><span class="lineNum"> 3169</span> : </span>
<span id="L3170"><span class="lineNum"> 3170</span> : constexpr _Float128</span>
<span id="L3171"><span class="lineNum"> 3171</span> : copysign(_Float128 __x, _Float128 __y)</span>
<span id="L3172"><span class="lineNum"> 3172</span> : { return __builtin_copysignf128(__x, __y); }</span>
<span id="L3173"><span class="lineNum"> 3173</span> : </span>
<span id="L3174"><span class="lineNum"> 3174</span> : constexpr _Float128</span>
<span id="L3175"><span class="lineNum"> 3175</span> : erf(_Float128 __x)</span>
<span id="L3176"><span class="lineNum"> 3176</span> : { return __builtin_erff128(__x); }</span>
<span id="L3177"><span class="lineNum"> 3177</span> : </span>
<span id="L3178"><span class="lineNum"> 3178</span> : constexpr _Float128</span>
<span id="L3179"><span class="lineNum"> 3179</span> : erfc(_Float128 __x)</span>
<span id="L3180"><span class="lineNum"> 3180</span> : { return __builtin_erfcf128(__x); }</span>
<span id="L3181"><span class="lineNum"> 3181</span> : </span>
<span id="L3182"><span class="lineNum"> 3182</span> : constexpr _Float128</span>
<span id="L3183"><span class="lineNum"> 3183</span> : exp2(_Float128 __x)</span>
<span id="L3184"><span class="lineNum"> 3184</span> : { return __builtin_exp2f128(__x); }</span>
<span id="L3185"><span class="lineNum"> 3185</span> : </span>
<span id="L3186"><span class="lineNum"> 3186</span> : constexpr _Float128</span>
<span id="L3187"><span class="lineNum"> 3187</span> : expm1(_Float128 __x)</span>
<span id="L3188"><span class="lineNum"> 3188</span> : { return __builtin_expm1f128(__x); }</span>
<span id="L3189"><span class="lineNum"> 3189</span> : </span>
<span id="L3190"><span class="lineNum"> 3190</span> : constexpr _Float128</span>
<span id="L3191"><span class="lineNum"> 3191</span> : fdim(_Float128 __x, _Float128 __y)</span>
<span id="L3192"><span class="lineNum"> 3192</span> : { return __builtin_fdimf128(__x, __y); }</span>
<span id="L3193"><span class="lineNum"> 3193</span> : </span>
<span id="L3194"><span class="lineNum"> 3194</span> : constexpr _Float128</span>
<span id="L3195"><span class="lineNum"> 3195</span> : fma(_Float128 __x, _Float128 __y, _Float128 __z)</span>
<span id="L3196"><span class="lineNum"> 3196</span> : { return __builtin_fmaf128(__x, __y, __z); }</span>
<span id="L3197"><span class="lineNum"> 3197</span> : </span>
<span id="L3198"><span class="lineNum"> 3198</span> : constexpr _Float128</span>
<span id="L3199"><span class="lineNum"> 3199</span> : fmax(_Float128 __x, _Float128 __y)</span>
<span id="L3200"><span class="lineNum"> 3200</span> : { return __builtin_fmaxf128(__x, __y); }</span>
<span id="L3201"><span class="lineNum"> 3201</span> : </span>
<span id="L3202"><span class="lineNum"> 3202</span> : constexpr _Float128</span>
<span id="L3203"><span class="lineNum"> 3203</span> : fmin(_Float128 __x, _Float128 __y)</span>
<span id="L3204"><span class="lineNum"> 3204</span> : { return __builtin_fminf128(__x, __y); }</span>
<span id="L3205"><span class="lineNum"> 3205</span> : </span>
<span id="L3206"><span class="lineNum"> 3206</span> : constexpr _Float128</span>
<span id="L3207"><span class="lineNum"> 3207</span> : hypot(_Float128 __x, _Float128 __y)</span>
<span id="L3208"><span class="lineNum"> 3208</span> : { return __builtin_hypotf128(__x, __y); }</span>
<span id="L3209"><span class="lineNum"> 3209</span> : </span>
<span id="L3210"><span class="lineNum"> 3210</span> : constexpr int</span>
<span id="L3211"><span class="lineNum"> 3211</span> : ilogb(_Float128 __x)</span>
<span id="L3212"><span class="lineNum"> 3212</span> : { return __builtin_ilogbf128(__x); }</span>
<span id="L3213"><span class="lineNum"> 3213</span> : </span>
<span id="L3214"><span class="lineNum"> 3214</span> : constexpr _Float128</span>
<span id="L3215"><span class="lineNum"> 3215</span> : lgamma(_Float128 __x)</span>
<span id="L3216"><span class="lineNum"> 3216</span> : { return __builtin_lgammaf128(__x); }</span>
<span id="L3217"><span class="lineNum"> 3217</span> : </span>
<span id="L3218"><span class="lineNum"> 3218</span> : constexpr long long</span>
<span id="L3219"><span class="lineNum"> 3219</span> : llrint(_Float128 __x)</span>
<span id="L3220"><span class="lineNum"> 3220</span> : { return __builtin_llrintf128(__x); }</span>
<span id="L3221"><span class="lineNum"> 3221</span> : </span>
<span id="L3222"><span class="lineNum"> 3222</span> : constexpr long long</span>
<span id="L3223"><span class="lineNum"> 3223</span> : llround(_Float128 __x)</span>
<span id="L3224"><span class="lineNum"> 3224</span> : { return __builtin_llroundf128(__x); }</span>
<span id="L3225"><span class="lineNum"> 3225</span> : </span>
<span id="L3226"><span class="lineNum"> 3226</span> : constexpr _Float128</span>
<span id="L3227"><span class="lineNum"> 3227</span> : log1p(_Float128 __x)</span>
<span id="L3228"><span class="lineNum"> 3228</span> : { return __builtin_log1pf128(__x); }</span>
<span id="L3229"><span class="lineNum"> 3229</span> : </span>
<span id="L3230"><span class="lineNum"> 3230</span> : // DR 568.</span>
<span id="L3231"><span class="lineNum"> 3231</span> : constexpr _Float128</span>
<span id="L3232"><span class="lineNum"> 3232</span> : log2(_Float128 __x)</span>
<span id="L3233"><span class="lineNum"> 3233</span> : { return __builtin_log2f128(__x); }</span>
<span id="L3234"><span class="lineNum"> 3234</span> : </span>
<span id="L3235"><span class="lineNum"> 3235</span> : constexpr _Float128</span>
<span id="L3236"><span class="lineNum"> 3236</span> : logb(_Float128 __x)</span>
<span id="L3237"><span class="lineNum"> 3237</span> : { return __builtin_logbf128(__x); }</span>
<span id="L3238"><span class="lineNum"> 3238</span> : </span>
<span id="L3239"><span class="lineNum"> 3239</span> : constexpr long</span>
<span id="L3240"><span class="lineNum"> 3240</span> : lrint(_Float128 __x)</span>
<span id="L3241"><span class="lineNum"> 3241</span> : { return __builtin_lrintf128(__x); }</span>
<span id="L3242"><span class="lineNum"> 3242</span> : </span>
<span id="L3243"><span class="lineNum"> 3243</span> : constexpr long</span>
<span id="L3244"><span class="lineNum"> 3244</span> : lround(_Float128 __x)</span>
<span id="L3245"><span class="lineNum"> 3245</span> : { return __builtin_lroundf128(__x); }</span>
<span id="L3246"><span class="lineNum"> 3246</span> : </span>
<span id="L3247"><span class="lineNum"> 3247</span> : constexpr _Float128</span>
<span id="L3248"><span class="lineNum"> 3248</span> : nearbyint(_Float128 __x)</span>
<span id="L3249"><span class="lineNum"> 3249</span> : { return __builtin_nearbyintf128(__x); }</span>
<span id="L3250"><span class="lineNum"> 3250</span> : </span>
<span id="L3251"><span class="lineNum"> 3251</span> : constexpr _Float128</span>
<span id="L3252"><span class="lineNum"> 3252</span> : nextafter(_Float128 __x, _Float128 __y)</span>
<span id="L3253"><span class="lineNum"> 3253</span> : { return __builtin_nextafterf128(__x, __y); }</span>
<span id="L3254"><span class="lineNum"> 3254</span> : </span>
<span id="L3255"><span class="lineNum"> 3255</span> : constexpr _Float128</span>
<span id="L3256"><span class="lineNum"> 3256</span> : remainder(_Float128 __x, _Float128 __y)</span>
<span id="L3257"><span class="lineNum"> 3257</span> : { return __builtin_remainderf128(__x, __y); }</span>
<span id="L3258"><span class="lineNum"> 3258</span> : </span>
<span id="L3259"><span class="lineNum"> 3259</span> : inline _Float128</span>
<span id="L3260"><span class="lineNum"> 3260</span> : remquo(_Float128 __x, _Float128 __y, int* __pquo)</span>
<span id="L3261"><span class="lineNum"> 3261</span> : { return __builtin_remquof128(__x, __y, __pquo); }</span>
<span id="L3262"><span class="lineNum"> 3262</span> : </span>
<span id="L3263"><span class="lineNum"> 3263</span> : constexpr _Float128</span>
<span id="L3264"><span class="lineNum"> 3264</span> : rint(_Float128 __x)</span>
<span id="L3265"><span class="lineNum"> 3265</span> : { return __builtin_rintf128(__x); }</span>
<span id="L3266"><span class="lineNum"> 3266</span> : </span>
<span id="L3267"><span class="lineNum"> 3267</span> : constexpr _Float128</span>
<span id="L3268"><span class="lineNum"> 3268</span> : round(_Float128 __x)</span>
<span id="L3269"><span class="lineNum"> 3269</span> : { return __builtin_roundf128(__x); }</span>
<span id="L3270"><span class="lineNum"> 3270</span> : </span>
<span id="L3271"><span class="lineNum"> 3271</span> : constexpr _Float128</span>
<span id="L3272"><span class="lineNum"> 3272</span> : scalbln(_Float128 __x, long __ex)</span>
<span id="L3273"><span class="lineNum"> 3273</span> : { return __builtin_scalblnf128(__x, __ex); }</span>
<span id="L3274"><span class="lineNum"> 3274</span> : </span>
<span id="L3275"><span class="lineNum"> 3275</span> : constexpr _Float128</span>
<span id="L3276"><span class="lineNum"> 3276</span> : scalbn(_Float128 __x, int __ex)</span>
<span id="L3277"><span class="lineNum"> 3277</span> : { return __builtin_scalbnf128(__x, __ex); }</span>
<span id="L3278"><span class="lineNum"> 3278</span> : </span>
<span id="L3279"><span class="lineNum"> 3279</span> : constexpr _Float128</span>
<span id="L3280"><span class="lineNum"> 3280</span> : tgamma(_Float128 __x)</span>
<span id="L3281"><span class="lineNum"> 3281</span> : { return __builtin_tgammaf128(__x); }</span>
<span id="L3282"><span class="lineNum"> 3282</span> : </span>
<span id="L3283"><span class="lineNum"> 3283</span> : constexpr _Float128</span>
<span id="L3284"><span class="lineNum"> 3284</span> : trunc(_Float128 __x)</span>
<span id="L3285"><span class="lineNum"> 3285</span> : { return __builtin_truncf128(__x); }</span>
<span id="L3286"><span class="lineNum"> 3286</span> : #endif</span>
<span id="L3287"><span class="lineNum"> 3287</span> : </span>
<span id="L3288"><span class="lineNum"> 3288</span> : #if defined(__STDCPP_BFLOAT16_T__) &amp;&amp; defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)</span>
<span id="L3289"><span class="lineNum"> 3289</span> : constexpr __gnu_cxx::__bfloat16_t</span>
<span id="L3290"><span class="lineNum"> 3290</span> : acosh(__gnu_cxx::__bfloat16_t __x)</span>
<span id="L3291"><span class="lineNum"> 3291</span> : { return __gnu_cxx::__bfloat16_t(__builtin_acoshf(__x)); }</span>
<span id="L3292"><span class="lineNum"> 3292</span> : </span>
<span id="L3293"><span class="lineNum"> 3293</span> : constexpr __gnu_cxx::__bfloat16_t</span>
<span id="L3294"><span class="lineNum"> 3294</span> : asinh(__gnu_cxx::__bfloat16_t __x)</span>
<span id="L3295"><span class="lineNum"> 3295</span> : { return __gnu_cxx::__bfloat16_t(__builtin_asinhf(__x)); }</span>
<span id="L3296"><span class="lineNum"> 3296</span> : </span>
<span id="L3297"><span class="lineNum"> 3297</span> : constexpr __gnu_cxx::__bfloat16_t</span>
<span id="L3298"><span class="lineNum"> 3298</span> : atanh(__gnu_cxx::__bfloat16_t __x)</span>
<span id="L3299"><span class="lineNum"> 3299</span> : { return __gnu_cxx::__bfloat16_t(__builtin_atanhf(__x)); }</span>
<span id="L3300"><span class="lineNum"> 3300</span> : </span>
<span id="L3301"><span class="lineNum"> 3301</span> : constexpr __gnu_cxx::__bfloat16_t</span>
<span id="L3302"><span class="lineNum"> 3302</span> : cbrt(__gnu_cxx::__bfloat16_t __x)</span>
<span id="L3303"><span class="lineNum"> 3303</span> : { return __gnu_cxx::__bfloat16_t(__builtin_cbrtf(__x)); }</span>
<span id="L3304"><span class="lineNum"> 3304</span> : </span>
<span id="L3305"><span class="lineNum"> 3305</span> : constexpr __gnu_cxx::__bfloat16_t</span>
<span id="L3306"><span class="lineNum"> 3306</span> : copysign(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)</span>
<span id="L3307"><span class="lineNum"> 3307</span> : { return __gnu_cxx::__bfloat16_t(__builtin_copysignf(__x, __y)); }</span>
<span id="L3308"><span class="lineNum"> 3308</span> : </span>
<span id="L3309"><span class="lineNum"> 3309</span> : constexpr __gnu_cxx::__bfloat16_t</span>
<span id="L3310"><span class="lineNum"> 3310</span> : erf(__gnu_cxx::__bfloat16_t __x)</span>
<span id="L3311"><span class="lineNum"> 3311</span> : { return __gnu_cxx::__bfloat16_t(__builtin_erff(__x)); }</span>
<span id="L3312"><span class="lineNum"> 3312</span> : </span>
<span id="L3313"><span class="lineNum"> 3313</span> : constexpr __gnu_cxx::__bfloat16_t</span>
<span id="L3314"><span class="lineNum"> 3314</span> : erfc(__gnu_cxx::__bfloat16_t __x)</span>
<span id="L3315"><span class="lineNum"> 3315</span> : { return __gnu_cxx::__bfloat16_t(__builtin_erfcf(__x)); }</span>
<span id="L3316"><span class="lineNum"> 3316</span> : </span>
<span id="L3317"><span class="lineNum"> 3317</span> : constexpr __gnu_cxx::__bfloat16_t</span>
<span id="L3318"><span class="lineNum"> 3318</span> : exp2(__gnu_cxx::__bfloat16_t __x)</span>
<span id="L3319"><span class="lineNum"> 3319</span> : { return __gnu_cxx::__bfloat16_t(__builtin_exp2f(__x)); }</span>
<span id="L3320"><span class="lineNum"> 3320</span> : </span>
<span id="L3321"><span class="lineNum"> 3321</span> : constexpr __gnu_cxx::__bfloat16_t</span>
<span id="L3322"><span class="lineNum"> 3322</span> : expm1(__gnu_cxx::__bfloat16_t __x)</span>
<span id="L3323"><span class="lineNum"> 3323</span> : { return __gnu_cxx::__bfloat16_t(__builtin_expm1f(__x)); }</span>
<span id="L3324"><span class="lineNum"> 3324</span> : </span>
<span id="L3325"><span class="lineNum"> 3325</span> : constexpr __gnu_cxx::__bfloat16_t</span>
<span id="L3326"><span class="lineNum"> 3326</span> : fdim(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)</span>
<span id="L3327"><span class="lineNum"> 3327</span> : { return __gnu_cxx::__bfloat16_t(__builtin_fdimf(__x, __y)); }</span>
<span id="L3328"><span class="lineNum"> 3328</span> : </span>
<span id="L3329"><span class="lineNum"> 3329</span> : constexpr __gnu_cxx::__bfloat16_t</span>
<span id="L3330"><span class="lineNum"> 3330</span> : fma(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y, __gnu_cxx::__bfloat16_t __z)</span>
<span id="L3331"><span class="lineNum"> 3331</span> : { return __gnu_cxx::__bfloat16_t(__builtin_fmaf(__x, __y, __z)); }</span>
<span id="L3332"><span class="lineNum"> 3332</span> : </span>
<span id="L3333"><span class="lineNum"> 3333</span> : constexpr __gnu_cxx::__bfloat16_t</span>
<span id="L3334"><span class="lineNum"> 3334</span> : fmax(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)</span>
<span id="L3335"><span class="lineNum"> 3335</span> : { return __gnu_cxx::__bfloat16_t(__builtin_fmaxf(__x, __y)); }</span>
<span id="L3336"><span class="lineNum"> 3336</span> : </span>
<span id="L3337"><span class="lineNum"> 3337</span> : constexpr __gnu_cxx::__bfloat16_t</span>
<span id="L3338"><span class="lineNum"> 3338</span> : fmin(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)</span>
<span id="L3339"><span class="lineNum"> 3339</span> : { return __gnu_cxx::__bfloat16_t(__builtin_fminf(__x, __y)); }</span>
<span id="L3340"><span class="lineNum"> 3340</span> : </span>
<span id="L3341"><span class="lineNum"> 3341</span> : constexpr __gnu_cxx::__bfloat16_t</span>
<span id="L3342"><span class="lineNum"> 3342</span> : hypot(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)</span>
<span id="L3343"><span class="lineNum"> 3343</span> : { return __gnu_cxx::__bfloat16_t(__builtin_hypotf(__x, __y)); }</span>
<span id="L3344"><span class="lineNum"> 3344</span> : </span>
<span id="L3345"><span class="lineNum"> 3345</span> : constexpr int</span>
<span id="L3346"><span class="lineNum"> 3346</span> : ilogb(__gnu_cxx::__bfloat16_t __x)</span>
<span id="L3347"><span class="lineNum"> 3347</span> : { return __gnu_cxx::__bfloat16_t(__builtin_ilogbf(__x)); }</span>
<span id="L3348"><span class="lineNum"> 3348</span> : </span>
<span id="L3349"><span class="lineNum"> 3349</span> : constexpr __gnu_cxx::__bfloat16_t</span>
<span id="L3350"><span class="lineNum"> 3350</span> : lgamma(__gnu_cxx::__bfloat16_t __x)</span>
<span id="L3351"><span class="lineNum"> 3351</span> : { return __gnu_cxx::__bfloat16_t(__builtin_lgammaf(__x)); }</span>
<span id="L3352"><span class="lineNum"> 3352</span> : </span>
<span id="L3353"><span class="lineNum"> 3353</span> : constexpr long long</span>
<span id="L3354"><span class="lineNum"> 3354</span> : llrint(__gnu_cxx::__bfloat16_t __x)</span>
<span id="L3355"><span class="lineNum"> 3355</span> : { return __gnu_cxx::__bfloat16_t(__builtin_llrintf(__x)); }</span>
<span id="L3356"><span class="lineNum"> 3356</span> : </span>
<span id="L3357"><span class="lineNum"> 3357</span> : constexpr long long</span>
<span id="L3358"><span class="lineNum"> 3358</span> : llround(__gnu_cxx::__bfloat16_t __x)</span>
<span id="L3359"><span class="lineNum"> 3359</span> : { return __gnu_cxx::__bfloat16_t(__builtin_llroundf(__x)); }</span>
<span id="L3360"><span class="lineNum"> 3360</span> : </span>
<span id="L3361"><span class="lineNum"> 3361</span> : constexpr __gnu_cxx::__bfloat16_t</span>
<span id="L3362"><span class="lineNum"> 3362</span> : log1p(__gnu_cxx::__bfloat16_t __x)</span>
<span id="L3363"><span class="lineNum"> 3363</span> : { return __gnu_cxx::__bfloat16_t(__builtin_log1pf(__x)); }</span>
<span id="L3364"><span class="lineNum"> 3364</span> : </span>
<span id="L3365"><span class="lineNum"> 3365</span> : // DR 568.</span>
<span id="L3366"><span class="lineNum"> 3366</span> : constexpr __gnu_cxx::__bfloat16_t</span>
<span id="L3367"><span class="lineNum"> 3367</span> : log2(__gnu_cxx::__bfloat16_t __x)</span>
<span id="L3368"><span class="lineNum"> 3368</span> : { return __gnu_cxx::__bfloat16_t(__builtin_log2f(__x)); }</span>
<span id="L3369"><span class="lineNum"> 3369</span> : </span>
<span id="L3370"><span class="lineNum"> 3370</span> : constexpr __gnu_cxx::__bfloat16_t</span>
<span id="L3371"><span class="lineNum"> 3371</span> : logb(__gnu_cxx::__bfloat16_t __x)</span>
<span id="L3372"><span class="lineNum"> 3372</span> : { return __gnu_cxx::__bfloat16_t(__builtin_logbf(__x)); }</span>
<span id="L3373"><span class="lineNum"> 3373</span> : </span>
<span id="L3374"><span class="lineNum"> 3374</span> : constexpr long</span>
<span id="L3375"><span class="lineNum"> 3375</span> : lrint(__gnu_cxx::__bfloat16_t __x)</span>
<span id="L3376"><span class="lineNum"> 3376</span> : { return __gnu_cxx::__bfloat16_t(__builtin_lrintf(__x)); }</span>
<span id="L3377"><span class="lineNum"> 3377</span> : </span>
<span id="L3378"><span class="lineNum"> 3378</span> : constexpr long</span>
<span id="L3379"><span class="lineNum"> 3379</span> : lround(__gnu_cxx::__bfloat16_t __x)</span>
<span id="L3380"><span class="lineNum"> 3380</span> : { return __gnu_cxx::__bfloat16_t(__builtin_lroundf(__x)); }</span>
<span id="L3381"><span class="lineNum"> 3381</span> : </span>
<span id="L3382"><span class="lineNum"> 3382</span> : constexpr __gnu_cxx::__bfloat16_t</span>
<span id="L3383"><span class="lineNum"> 3383</span> : nearbyint(__gnu_cxx::__bfloat16_t __x)</span>
<span id="L3384"><span class="lineNum"> 3384</span> : { return __gnu_cxx::__bfloat16_t(__builtin_nearbyintf(__x)); }</span>
<span id="L3385"><span class="lineNum"> 3385</span> : </span>
<span id="L3386"><span class="lineNum"> 3386</span> : constexpr __gnu_cxx::__bfloat16_t</span>
<span id="L3387"><span class="lineNum"> 3387</span> : nextafter(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)</span>
<span id="L3388"><span class="lineNum"> 3388</span> : {</span>
<span id="L3389"><span class="lineNum"> 3389</span> : if (std::__is_constant_evaluated())</span>
<span id="L3390"><span class="lineNum"> 3390</span> : return __builtin_nextafterf16b(__x, __y);</span>
<span id="L3391"><span class="lineNum"> 3391</span> : #ifdef __INT16_TYPE__</span>
<span id="L3392"><span class="lineNum"> 3392</span> : using __bfloat16_int_type = __INT16_TYPE__;</span>
<span id="L3393"><span class="lineNum"> 3393</span> : #else</span>
<span id="L3394"><span class="lineNum"> 3394</span> : using __bfloat16_int_type = short int;</span>
<span id="L3395"><span class="lineNum"> 3395</span> : #endif</span>
<span id="L3396"><span class="lineNum"> 3396</span> : __bfloat16_int_type __hx, __hy, __ix, __iy;</span>
<span id="L3397"><span class="lineNum"> 3397</span> : __builtin_memcpy(&amp;__hx, &amp;__x, sizeof(__x));</span>
<span id="L3398"><span class="lineNum"> 3398</span> : __builtin_memcpy(&amp;__hy, &amp;__y, sizeof(__x));</span>
<span id="L3399"><span class="lineNum"> 3399</span> : __ix = __hx &amp; 0x7fff; // |x|</span>
<span id="L3400"><span class="lineNum"> 3400</span> : __iy = __hy &amp; 0x7fff; // |y|</span>
<span id="L3401"><span class="lineNum"> 3401</span> : if (__ix &gt; 0x7f80 || __iy &gt; 0x7f80) // x or y is NaN</span>
<span id="L3402"><span class="lineNum"> 3402</span> : return __x + __y;</span>
<span id="L3403"><span class="lineNum"> 3403</span> : if (__x == __y)</span>
<span id="L3404"><span class="lineNum"> 3404</span> : return __y; // x == y, return y</span>
<span id="L3405"><span class="lineNum"> 3405</span> : if (__ix == 0) // x == 0</span>
<span id="L3406"><span class="lineNum"> 3406</span> : {</span>
<span id="L3407"><span class="lineNum"> 3407</span> : __hy = (__hy &amp; 0x8000) | 1; // return +-__BFLT16_DENORM_MIN__</span>
<span id="L3408"><span class="lineNum"> 3408</span> : __builtin_memcpy(&amp;__x, &amp;__hy, sizeof(__x));</span>
<span id="L3409"><span class="lineNum"> 3409</span> : __builtin_nextafterf(0.0f, 1.0f); // raise underflow</span>
<span id="L3410"><span class="lineNum"> 3410</span> : return __x;</span>
<span id="L3411"><span class="lineNum"> 3411</span> : }</span>
<span id="L3412"><span class="lineNum"> 3412</span> : if (__hx &gt;= 0) // x &gt; 0</span>
<span id="L3413"><span class="lineNum"> 3413</span> : {</span>
<span id="L3414"><span class="lineNum"> 3414</span> : if (__hx &gt; __hy) // x &gt; y, x -= ulp</span>
<span id="L3415"><span class="lineNum"> 3415</span> : --__hx;</span>
<span id="L3416"><span class="lineNum"> 3416</span> : else // x &lt; y, x += ulp</span>
<span id="L3417"><span class="lineNum"> 3417</span> : ++__hx;</span>
<span id="L3418"><span class="lineNum"> 3418</span> : }</span>
<span id="L3419"><span class="lineNum"> 3419</span> : else // x &lt; 0</span>
<span id="L3420"><span class="lineNum"> 3420</span> : {</span>
<span id="L3421"><span class="lineNum"> 3421</span> : if (__hy &gt;= 0 || __hx &gt; __hy) // x &lt; y, x -= ulp</span>
<span id="L3422"><span class="lineNum"> 3422</span> : --__hx;</span>
<span id="L3423"><span class="lineNum"> 3423</span> : else // x &gt; y, x += ulp</span>
<span id="L3424"><span class="lineNum"> 3424</span> : ++__hx;</span>
<span id="L3425"><span class="lineNum"> 3425</span> : }</span>
<span id="L3426"><span class="lineNum"> 3426</span> : __hy = __hx &amp; 0x7f80;</span>
<span id="L3427"><span class="lineNum"> 3427</span> : if (__hy &gt;= 0x7f80)</span>
<span id="L3428"><span class="lineNum"> 3428</span> : __builtin_nextafterf(__FLT_MAX__, __builtin_inff()); // overflow</span>
<span id="L3429"><span class="lineNum"> 3429</span> : else if (__hy &lt; 0x0080)</span>
<span id="L3430"><span class="lineNum"> 3430</span> : __builtin_nextafterf(__FLT_MIN__, 0.0f); // underflow</span>
<span id="L3431"><span class="lineNum"> 3431</span> : __builtin_memcpy(&amp;__x, &amp;__hx, sizeof(__x));</span>
<span id="L3432"><span class="lineNum"> 3432</span> : return __x;</span>
<span id="L3433"><span class="lineNum"> 3433</span> : }</span>
<span id="L3434"><span class="lineNum"> 3434</span> : </span>
<span id="L3435"><span class="lineNum"> 3435</span> : constexpr __gnu_cxx::__bfloat16_t</span>
<span id="L3436"><span class="lineNum"> 3436</span> : remainder(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)</span>
<span id="L3437"><span class="lineNum"> 3437</span> : { return __gnu_cxx::__bfloat16_t(__builtin_remainderf(__x, __y)); }</span>
<span id="L3438"><span class="lineNum"> 3438</span> : </span>
<span id="L3439"><span class="lineNum"> 3439</span> : inline __gnu_cxx::__bfloat16_t</span>
<span id="L3440"><span class="lineNum"> 3440</span> : remquo(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y, int* __pquo)</span>
<span id="L3441"><span class="lineNum"> 3441</span> : { return __gnu_cxx::__bfloat16_t(__builtin_remquof(__x, __y, __pquo)); }</span>
<span id="L3442"><span class="lineNum"> 3442</span> : </span>
<span id="L3443"><span class="lineNum"> 3443</span> : constexpr __gnu_cxx::__bfloat16_t</span>
<span id="L3444"><span class="lineNum"> 3444</span> : rint(__gnu_cxx::__bfloat16_t __x)</span>
<span id="L3445"><span class="lineNum"> 3445</span> : { return __gnu_cxx::__bfloat16_t(__builtin_rintf(__x)); }</span>
<span id="L3446"><span class="lineNum"> 3446</span> : </span>
<span id="L3447"><span class="lineNum"> 3447</span> : constexpr __gnu_cxx::__bfloat16_t</span>
<span id="L3448"><span class="lineNum"> 3448</span> : round(__gnu_cxx::__bfloat16_t __x)</span>
<span id="L3449"><span class="lineNum"> 3449</span> : { return __gnu_cxx::__bfloat16_t(__builtin_roundf(__x)); }</span>
<span id="L3450"><span class="lineNum"> 3450</span> : </span>
<span id="L3451"><span class="lineNum"> 3451</span> : constexpr __gnu_cxx::__bfloat16_t</span>
<span id="L3452"><span class="lineNum"> 3452</span> : scalbln(__gnu_cxx::__bfloat16_t __x, long __ex)</span>
<span id="L3453"><span class="lineNum"> 3453</span> : { return __gnu_cxx::__bfloat16_t(__builtin_scalblnf(__x, __ex)); }</span>
<span id="L3454"><span class="lineNum"> 3454</span> : </span>
<span id="L3455"><span class="lineNum"> 3455</span> : constexpr __gnu_cxx::__bfloat16_t</span>
<span id="L3456"><span class="lineNum"> 3456</span> : scalbn(__gnu_cxx::__bfloat16_t __x, int __ex)</span>
<span id="L3457"><span class="lineNum"> 3457</span> : { return __gnu_cxx::__bfloat16_t(__builtin_scalbnf(__x, __ex)); }</span>
<span id="L3458"><span class="lineNum"> 3458</span> : </span>
<span id="L3459"><span class="lineNum"> 3459</span> : constexpr __gnu_cxx::__bfloat16_t</span>
<span id="L3460"><span class="lineNum"> 3460</span> : tgamma(__gnu_cxx::__bfloat16_t __x)</span>
<span id="L3461"><span class="lineNum"> 3461</span> : { return __gnu_cxx::__bfloat16_t(__builtin_tgammaf(__x)); }</span>
<span id="L3462"><span class="lineNum"> 3462</span> : </span>
<span id="L3463"><span class="lineNum"> 3463</span> : constexpr __gnu_cxx::__bfloat16_t</span>
<span id="L3464"><span class="lineNum"> 3464</span> : trunc(__gnu_cxx::__bfloat16_t __x)</span>
<span id="L3465"><span class="lineNum"> 3465</span> : { return __gnu_cxx::__bfloat16_t(__builtin_truncf(__x)); }</span>
<span id="L3466"><span class="lineNum"> 3466</span> : #endif</span>
<span id="L3467"><span class="lineNum"> 3467</span> : </span>
<span id="L3468"><span class="lineNum"> 3468</span> : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT</span>
<span id="L3469"><span class="lineNum"> 3469</span> : template&lt;typename _Tp, typename _Up&gt;</span>
<span id="L3470"><span class="lineNum"> 3470</span> : constexpr typename __gnu_cxx::__promote_2&lt;_Tp, _Up&gt;::__type</span>
<span id="L3471"><span class="lineNum"> 3471</span> : copysign(_Tp __x, _Up __y)</span>
<span id="L3472"><span class="lineNum"> 3472</span> : {</span>
<span id="L3473"><span class="lineNum"> 3473</span> : typedef typename __gnu_cxx::__promote_2&lt;_Tp, _Up&gt;::__type __type;</span>
<span id="L3474"><span class="lineNum"> 3474</span> : return copysign(__type(__x), __type(__y));</span>
<span id="L3475"><span class="lineNum"> 3475</span> : }</span>
<span id="L3476"><span class="lineNum"> 3476</span> : </span>
<span id="L3477"><span class="lineNum"> 3477</span> : template&lt;typename _Tp, typename _Up&gt;</span>
<span id="L3478"><span class="lineNum"> 3478</span> : constexpr typename __gnu_cxx::__promote_2&lt;_Tp, _Up&gt;::__type</span>
<span id="L3479"><span class="lineNum"> 3479</span> : fdim(_Tp __x, _Up __y)</span>
<span id="L3480"><span class="lineNum"> 3480</span> : {</span>
<span id="L3481"><span class="lineNum"> 3481</span> : typedef typename __gnu_cxx::__promote_2&lt;_Tp, _Up&gt;::__type __type;</span>
<span id="L3482"><span class="lineNum"> 3482</span> : return fdim(__type(__x), __type(__y));</span>
<span id="L3483"><span class="lineNum"> 3483</span> : }</span>
<span id="L3484"><span class="lineNum"> 3484</span> : </span>
<span id="L3485"><span class="lineNum"> 3485</span> : template&lt;typename _Tp, typename _Up&gt;</span>
<span id="L3486"><span class="lineNum"> 3486</span> : constexpr typename __gnu_cxx::__promote_2&lt;_Tp, _Up&gt;::__type</span>
<span id="L3487"><span class="lineNum"> 3487</span> : fmax(_Tp __x, _Up __y)</span>
<span id="L3488"><span class="lineNum"> 3488</span> : {</span>
<span id="L3489"><span class="lineNum"> 3489</span> : typedef typename __gnu_cxx::__promote_2&lt;_Tp, _Up&gt;::__type __type;</span>
<span id="L3490"><span class="lineNum"> 3490</span> : return fmax(__type(__x), __type(__y));</span>
<span id="L3491"><span class="lineNum"> 3491</span> : }</span>
<span id="L3492"><span class="lineNum"> 3492</span> : </span>
<span id="L3493"><span class="lineNum"> 3493</span> : template&lt;typename _Tp, typename _Up&gt;</span>
<span id="L3494"><span class="lineNum"> 3494</span> : constexpr typename __gnu_cxx::__promote_2&lt;_Tp, _Up&gt;::__type</span>
<span id="L3495"><span class="lineNum"> 3495</span> : fmin(_Tp __x, _Up __y)</span>
<span id="L3496"><span class="lineNum"> 3496</span> : {</span>
<span id="L3497"><span class="lineNum"> 3497</span> : typedef typename __gnu_cxx::__promote_2&lt;_Tp, _Up&gt;::__type __type;</span>
<span id="L3498"><span class="lineNum"> 3498</span> : return fmin(__type(__x), __type(__y));</span>
<span id="L3499"><span class="lineNum"> 3499</span> : }</span>
<span id="L3500"><span class="lineNum"> 3500</span> : </span>
<span id="L3501"><span class="lineNum"> 3501</span> : template&lt;typename _Tp, typename _Up&gt;</span>
<span id="L3502"><span class="lineNum"> 3502</span> : constexpr typename __gnu_cxx::__promote_2&lt;_Tp, _Up&gt;::__type</span>
<span id="L3503"><span class="lineNum"> 3503</span> : hypot(_Tp __x, _Up __y)</span>
<span id="L3504"><span class="lineNum"> 3504</span> : {</span>
<span id="L3505"><span class="lineNum"> 3505</span> : typedef typename __gnu_cxx::__promote_2&lt;_Tp, _Up&gt;::__type __type;</span>
<span id="L3506"><span class="lineNum"> 3506</span> : return hypot(__type(__x), __type(__y));</span>
<span id="L3507"><span class="lineNum"> 3507</span> : }</span>
<span id="L3508"><span class="lineNum"> 3508</span> : </span>
<span id="L3509"><span class="lineNum"> 3509</span> : template&lt;typename _Tp, typename _Up&gt;</span>
<span id="L3510"><span class="lineNum"> 3510</span> : constexpr typename __gnu_cxx::__promote_2&lt;_Tp, _Up&gt;::__type</span>
<span id="L3511"><span class="lineNum"> 3511</span> : nextafter(_Tp __x, _Up __y)</span>
<span id="L3512"><span class="lineNum"> 3512</span> : {</span>
<span id="L3513"><span class="lineNum"> 3513</span> : typedef typename __gnu_cxx::__promote_2&lt;_Tp, _Up&gt;::__type __type;</span>
<span id="L3514"><span class="lineNum"> 3514</span> : return nextafter(__type(__x), __type(__y));</span>
<span id="L3515"><span class="lineNum"> 3515</span> : }</span>
<span id="L3516"><span class="lineNum"> 3516</span> : </span>
<span id="L3517"><span class="lineNum"> 3517</span> : template&lt;typename _Tp, typename _Up&gt;</span>
<span id="L3518"><span class="lineNum"> 3518</span> : constexpr typename __gnu_cxx::__promote_2&lt;_Tp, _Up&gt;::__type</span>
<span id="L3519"><span class="lineNum"> 3519</span> : remainder(_Tp __x, _Up __y)</span>
<span id="L3520"><span class="lineNum"> 3520</span> : {</span>
<span id="L3521"><span class="lineNum"> 3521</span> : typedef typename __gnu_cxx::__promote_2&lt;_Tp, _Up&gt;::__type __type;</span>
<span id="L3522"><span class="lineNum"> 3522</span> : return remainder(__type(__x), __type(__y));</span>
<span id="L3523"><span class="lineNum"> 3523</span> : }</span>
<span id="L3524"><span class="lineNum"> 3524</span> : </span>
<span id="L3525"><span class="lineNum"> 3525</span> : template&lt;typename _Tp, typename _Up&gt;</span>
<span id="L3526"><span class="lineNum"> 3526</span> : inline typename __gnu_cxx::__promote_2&lt;_Tp, _Up&gt;::__type</span>
<span id="L3527"><span class="lineNum"> 3527</span> : remquo(_Tp __x, _Up __y, int* __pquo)</span>
<span id="L3528"><span class="lineNum"> 3528</span> : {</span>
<span id="L3529"><span class="lineNum"> 3529</span> : typedef typename __gnu_cxx::__promote_2&lt;_Tp, _Up&gt;::__type __type;</span>
<span id="L3530"><span class="lineNum"> 3530</span> : return remquo(__type(__x), __type(__y), __pquo);</span>
<span id="L3531"><span class="lineNum"> 3531</span> : }</span>
<span id="L3532"><span class="lineNum"> 3532</span> : </span>
<span id="L3533"><span class="lineNum"> 3533</span> : template&lt;typename _Tp, typename _Up, typename _Vp&gt;</span>
<span id="L3534"><span class="lineNum"> 3534</span> : constexpr typename __gnu_cxx::__promote_3&lt;_Tp, _Up, _Vp&gt;::__type</span>
<span id="L3535"><span class="lineNum"> 3535</span> : fma(_Tp __x, _Up __y, _Vp __z)</span>
<span id="L3536"><span class="lineNum"> 3536</span> : {</span>
<span id="L3537"><span class="lineNum"> 3537</span> : typedef typename __gnu_cxx::__promote_3&lt;_Tp, _Up, _Vp&gt;::__type __type;</span>
<span id="L3538"><span class="lineNum"> 3538</span> : return fma(__type(__x), __type(__y), __type(__z));</span>
<span id="L3539"><span class="lineNum"> 3539</span> : }</span>
<span id="L3540"><span class="lineNum"> 3540</span> : #endif</span>
<span id="L3541"><span class="lineNum"> 3541</span> : </span>
<span id="L3542"><span class="lineNum"> 3542</span> : #endif // _GLIBCXX_USE_C99_MATH_TR1</span>
<span id="L3543"><span class="lineNum"> 3543</span> : #endif // C++11</span>
<span id="L3544"><span class="lineNum"> 3544</span> : </span>
<span id="L3545"><span class="lineNum"> 3545</span> : #if __cplusplus &gt;= 201703L</span>
<span id="L3546"><span class="lineNum"> 3546</span> : </span>
<span id="L3547"><span class="lineNum"> 3547</span> : // [c.math.hypot3], three-dimensional hypotenuse</span>
<span id="L3548"><span class="lineNum"> 3548</span> : #define __cpp_lib_hypot 201603L</span>
<span id="L3549"><span class="lineNum"> 3549</span> : </span>
<span id="L3550"><span class="lineNum"> 3550</span> : template&lt;typename _Tp&gt;</span>
<span id="L3551"><span class="lineNum"> 3551</span> : inline _Tp</span>
<span id="L3552"><span class="lineNum"> 3552</span> : __hypot3(_Tp __x, _Tp __y, _Tp __z)</span>
<span id="L3553"><span class="lineNum"> 3553</span> : {</span>
<span id="L3554"><span class="lineNum"> 3554</span> : __x = std::abs(__x);</span>
<span id="L3555"><span class="lineNum"> 3555</span> : __y = std::abs(__y);</span>
<span id="L3556"><span class="lineNum"> 3556</span> : __z = std::abs(__z);</span>
<span id="L3557"><span class="lineNum"> 3557</span> : if (_Tp __a = __x &lt; __y ? __y &lt; __z ? __z : __y : __x &lt; __z ? __z : __x)</span>
<span id="L3558"><span class="lineNum"> 3558</span> : return __a * std::sqrt((__x / __a) * (__x / __a)</span>
<span id="L3559"><span class="lineNum"> 3559</span> : + (__y / __a) * (__y / __a)</span>
<span id="L3560"><span class="lineNum"> 3560</span> : + (__z / __a) * (__z / __a));</span>
<span id="L3561"><span class="lineNum"> 3561</span> : else</span>
<span id="L3562"><span class="lineNum"> 3562</span> : return {};</span>
<span id="L3563"><span class="lineNum"> 3563</span> : }</span>
<span id="L3564"><span class="lineNum"> 3564</span> : </span>
<span id="L3565"><span class="lineNum"> 3565</span> : inline float</span>
<span id="L3566"><span class="lineNum"> 3566</span> : hypot(float __x, float __y, float __z)</span>
<span id="L3567"><span class="lineNum"> 3567</span> : { return std::__hypot3&lt;float&gt;(__x, __y, __z); }</span>
<span id="L3568"><span class="lineNum"> 3568</span> : </span>
<span id="L3569"><span class="lineNum"> 3569</span> : inline double</span>
<span id="L3570"><span class="lineNum"> 3570</span> : hypot(double __x, double __y, double __z)</span>
<span id="L3571"><span class="lineNum"> 3571</span> : { return std::__hypot3&lt;double&gt;(__x, __y, __z); }</span>
<span id="L3572"><span class="lineNum"> 3572</span> : </span>
<span id="L3573"><span class="lineNum"> 3573</span> : inline long double</span>
<span id="L3574"><span class="lineNum"> 3574</span> : hypot(long double __x, long double __y, long double __z)</span>
<span id="L3575"><span class="lineNum"> 3575</span> : { return std::__hypot3&lt;long double&gt;(__x, __y, __z); }</span>
<span id="L3576"><span class="lineNum"> 3576</span> : </span>
<span id="L3577"><span class="lineNum"> 3577</span> : template&lt;typename _Tp, typename _Up, typename _Vp&gt;</span>
<span id="L3578"><span class="lineNum"> 3578</span> : __gnu_cxx::__promoted_t&lt;_Tp, _Up, _Vp&gt;</span>
<span id="L3579"><span class="lineNum"> 3579</span> : hypot(_Tp __x, _Up __y, _Vp __z)</span>
<span id="L3580"><span class="lineNum"> 3580</span> : {</span>
<span id="L3581"><span class="lineNum"> 3581</span> : using __type = __gnu_cxx::__promoted_t&lt;_Tp, _Up, _Vp&gt;;</span>
<span id="L3582"><span class="lineNum"> 3582</span> : return std::__hypot3&lt;__type&gt;(__x, __y, __z);</span>
<span id="L3583"><span class="lineNum"> 3583</span> : }</span>
<span id="L3584"><span class="lineNum"> 3584</span> : </span>
<span id="L3585"><span class="lineNum"> 3585</span> : #if defined(__STDCPP_FLOAT16_T__) &amp;&amp; defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)</span>
<span id="L3586"><span class="lineNum"> 3586</span> : inline _Float16</span>
<span id="L3587"><span class="lineNum"> 3587</span> : hypot(_Float16 __x, _Float16 __y, _Float16 __z)</span>
<span id="L3588"><span class="lineNum"> 3588</span> : { return std::__hypot3&lt;_Float16&gt;(__x, __y, __z); }</span>
<span id="L3589"><span class="lineNum"> 3589</span> : #endif</span>
<span id="L3590"><span class="lineNum"> 3590</span> : </span>
<span id="L3591"><span class="lineNum"> 3591</span> : #if defined(__STDCPP_FLOAT32_T__) &amp;&amp; defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)</span>
<span id="L3592"><span class="lineNum"> 3592</span> : inline _Float32</span>
<span id="L3593"><span class="lineNum"> 3593</span> : hypot(_Float32 __x, _Float32 __y, _Float32 __z)</span>
<span id="L3594"><span class="lineNum"> 3594</span> : { return std::__hypot3&lt;_Float32&gt;(__x, __y, __z); }</span>
<span id="L3595"><span class="lineNum"> 3595</span> : #endif</span>
<span id="L3596"><span class="lineNum"> 3596</span> : </span>
<span id="L3597"><span class="lineNum"> 3597</span> : #if defined(__STDCPP_FLOAT64_T__) &amp;&amp; defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)</span>
<span id="L3598"><span class="lineNum"> 3598</span> : inline _Float64</span>
<span id="L3599"><span class="lineNum"> 3599</span> : hypot(_Float64 __x, _Float64 __y, _Float64 __z)</span>
<span id="L3600"><span class="lineNum"> 3600</span> : { return std::__hypot3&lt;_Float64&gt;(__x, __y, __z); }</span>
<span id="L3601"><span class="lineNum"> 3601</span> : #endif</span>
<span id="L3602"><span class="lineNum"> 3602</span> : </span>
<span id="L3603"><span class="lineNum"> 3603</span> : #if defined(__STDCPP_FLOAT128_T__) \</span>
<span id="L3604"><span class="lineNum"> 3604</span> : &amp;&amp; (defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128) \</span>
<span id="L3605"><span class="lineNum"> 3605</span> : || defined(_GLIBCXX_HAVE_FLOAT128_MATH))</span>
<span id="L3606"><span class="lineNum"> 3606</span> : inline _Float128</span>
<span id="L3607"><span class="lineNum"> 3607</span> : hypot(_Float128 __x, _Float128 __y, _Float128 __z)</span>
<span id="L3608"><span class="lineNum"> 3608</span> : { return std::__hypot3&lt;_Float128&gt;(__x, __y, __z); }</span>
<span id="L3609"><span class="lineNum"> 3609</span> : #endif</span>
<span id="L3610"><span class="lineNum"> 3610</span> : </span>
<span id="L3611"><span class="lineNum"> 3611</span> : #if defined(__STDCPP_BFLOAT16_T__) &amp;&amp; defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)</span>
<span id="L3612"><span class="lineNum"> 3612</span> : inline __gnu_cxx::__bfloat16_t</span>
<span id="L3613"><span class="lineNum"> 3613</span> : hypot(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y, __gnu_cxx::__bfloat16_t __z)</span>
<span id="L3614"><span class="lineNum"> 3614</span> : { return std::__hypot3&lt;__gnu_cxx::__bfloat16_t&gt;(__x, __y, __z); }</span>
<span id="L3615"><span class="lineNum"> 3615</span> : #endif</span>
<span id="L3616"><span class="lineNum"> 3616</span> : </span>
<span id="L3617"><span class="lineNum"> 3617</span> : #endif // C++17</span>
<span id="L3618"><span class="lineNum"> 3618</span> : </span>
<span id="L3619"><span class="lineNum"> 3619</span> : #if __cplusplus &gt;= 202002L</span>
<span id="L3620"><span class="lineNum"> 3620</span> : // linear interpolation</span>
<span id="L3621"><span class="lineNum"> 3621</span> : # define __cpp_lib_interpolate 201902L</span>
<span id="L3622"><span class="lineNum"> 3622</span> : </span>
<span id="L3623"><span class="lineNum"> 3623</span> : template&lt;typename _Fp&gt;</span>
<span id="L3624"><span class="lineNum"> 3624</span> : constexpr _Fp</span>
<span id="L3625"><span class="lineNum"> 3625</span> : __lerp(_Fp __a, _Fp __b, _Fp __t) noexcept</span>
<span id="L3626"><span class="lineNum"> 3626</span> : {</span>
<span id="L3627"><span class="lineNum"> 3627</span> : if ((__a &lt;= 0 &amp;&amp; __b &gt;= 0) || (__a &gt;= 0 &amp;&amp; __b &lt;= 0))</span>
<span id="L3628"><span class="lineNum"> 3628</span> : return __t * __b + (1 - __t) * __a;</span>
<span id="L3629"><span class="lineNum"> 3629</span> : </span>
<span id="L3630"><span class="lineNum"> 3630</span> : if (__t == 1)</span>
<span id="L3631"><span class="lineNum"> 3631</span> : return __b; // exact</span>
<span id="L3632"><span class="lineNum"> 3632</span> : </span>
<span id="L3633"><span class="lineNum"> 3633</span> : // Exact at __t=0, monotonic except near __t=1,</span>
<span id="L3634"><span class="lineNum"> 3634</span> : // bounded, determinate, and consistent:</span>
<span id="L3635"><span class="lineNum"> 3635</span> : const _Fp __x = __a + __t * (__b - __a);</span>
<span id="L3636"><span class="lineNum"> 3636</span> : return (__t &gt; 1) == (__b &gt; __a)</span>
<span id="L3637"><span class="lineNum"> 3637</span> : ? (__b &lt; __x ? __x : __b)</span>
<span id="L3638"><span class="lineNum"> 3638</span> : : (__b &gt; __x ? __x : __b); // monotonic near __t=1</span>
<span id="L3639"><span class="lineNum"> 3639</span> : }</span>
<span id="L3640"><span class="lineNum"> 3640</span> : </span>
<span id="L3641"><span class="lineNum"> 3641</span> : constexpr float</span>
<span id="L3642"><span class="lineNum"> 3642</span> : lerp(float __a, float __b, float __t) noexcept</span>
<span id="L3643"><span class="lineNum"> 3643</span> : { return std::__lerp(__a, __b, __t); }</span>
<span id="L3644"><span class="lineNum"> 3644</span> : </span>
<span id="L3645"><span class="lineNum"> 3645</span> : constexpr double</span>
<span id="L3646"><span class="lineNum"> 3646</span> : lerp(double __a, double __b, double __t) noexcept</span>
<span id="L3647"><span class="lineNum"> 3647</span> : { return std::__lerp(__a, __b, __t); }</span>
<span id="L3648"><span class="lineNum"> 3648</span> : </span>
<span id="L3649"><span class="lineNum"> 3649</span> : constexpr long double</span>
<span id="L3650"><span class="lineNum"> 3650</span> : lerp(long double __a, long double __b, long double __t) noexcept</span>
<span id="L3651"><span class="lineNum"> 3651</span> : { return std::__lerp(__a, __b, __t); }</span>
<span id="L3652"><span class="lineNum"> 3652</span> : </span>
<span id="L3653"><span class="lineNum"> 3653</span> : template&lt;typename _Tp, typename _Up, typename _Vp&gt;</span>
<span id="L3654"><span class="lineNum"> 3654</span> : constexpr __gnu_cxx::__promoted_t&lt;_Tp, _Up, _Vp&gt;</span>
<span id="L3655"><span class="lineNum"> 3655</span> : lerp(_Tp __x, _Up __y, _Vp __z) noexcept</span>
<span id="L3656"><span class="lineNum"> 3656</span> : {</span>
<span id="L3657"><span class="lineNum"> 3657</span> : using __type = __gnu_cxx::__promoted_t&lt;_Tp, _Up, _Vp&gt;;</span>
<span id="L3658"><span class="lineNum"> 3658</span> : return std::__lerp&lt;__type&gt;(__x, __y, __z);</span>
<span id="L3659"><span class="lineNum"> 3659</span> : }</span>
<span id="L3660"><span class="lineNum"> 3660</span> : </span>
<span id="L3661"><span class="lineNum"> 3661</span> : #if defined(__STDCPP_FLOAT16_T__) &amp;&amp; defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)</span>
<span id="L3662"><span class="lineNum"> 3662</span> : inline _Float16</span>
<span id="L3663"><span class="lineNum"> 3663</span> : lerp(_Float16 __x, _Float16 __y, _Float16 __z) noexcept</span>
<span id="L3664"><span class="lineNum"> 3664</span> : { return std::__lerp&lt;_Float16&gt;(__x, __y, __z); }</span>
<span id="L3665"><span class="lineNum"> 3665</span> : #endif</span>
<span id="L3666"><span class="lineNum"> 3666</span> : </span>
<span id="L3667"><span class="lineNum"> 3667</span> : #if defined(__STDCPP_FLOAT32_T__) &amp;&amp; defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)</span>
<span id="L3668"><span class="lineNum"> 3668</span> : inline _Float32</span>
<span id="L3669"><span class="lineNum"> 3669</span> : lerp(_Float32 __x, _Float32 __y, _Float32 __z) noexcept</span>
<span id="L3670"><span class="lineNum"> 3670</span> : { return std::__lerp&lt;_Float32&gt;(__x, __y, __z); }</span>
<span id="L3671"><span class="lineNum"> 3671</span> : #endif</span>
<span id="L3672"><span class="lineNum"> 3672</span> : </span>
<span id="L3673"><span class="lineNum"> 3673</span> : #if defined(__STDCPP_FLOAT64_T__) &amp;&amp; defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)</span>
<span id="L3674"><span class="lineNum"> 3674</span> : inline _Float64</span>
<span id="L3675"><span class="lineNum"> 3675</span> : lerp(_Float64 __x, _Float64 __y, _Float64 __z) noexcept</span>
<span id="L3676"><span class="lineNum"> 3676</span> : { return std::__lerp&lt;_Float64&gt;(__x, __y, __z); }</span>
<span id="L3677"><span class="lineNum"> 3677</span> : #endif</span>
<span id="L3678"><span class="lineNum"> 3678</span> : </span>
<span id="L3679"><span class="lineNum"> 3679</span> : #if defined(__STDCPP_FLOAT128_T__) \</span>
<span id="L3680"><span class="lineNum"> 3680</span> : &amp;&amp; (defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128) \</span>
<span id="L3681"><span class="lineNum"> 3681</span> : || defined(_GLIBCXX_HAVE_FLOAT128_MATH))</span>
<span id="L3682"><span class="lineNum"> 3682</span> : inline _Float128</span>
<span id="L3683"><span class="lineNum"> 3683</span> : lerp(_Float128 __x, _Float128 __y, _Float128 __z) noexcept</span>
<span id="L3684"><span class="lineNum"> 3684</span> : { return std::__lerp&lt;_Float128&gt;(__x, __y, __z); }</span>
<span id="L3685"><span class="lineNum"> 3685</span> : #endif</span>
<span id="L3686"><span class="lineNum"> 3686</span> : </span>
<span id="L3687"><span class="lineNum"> 3687</span> : #if defined(__STDCPP_BFLOAT16_T__) &amp;&amp; defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)</span>
<span id="L3688"><span class="lineNum"> 3688</span> : inline __gnu_cxx::__bfloat16_t</span>
<span id="L3689"><span class="lineNum"> 3689</span> : lerp(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y, __gnu_cxx::__bfloat16_t __z) noexcept</span>
<span id="L3690"><span class="lineNum"> 3690</span> : { return std::__lerp&lt;__gnu_cxx::__bfloat16_t&gt;(__x, __y, __z); }</span>
<span id="L3691"><span class="lineNum"> 3691</span> : #endif</span>
<span id="L3692"><span class="lineNum"> 3692</span> : </span>
<span id="L3693"><span class="lineNum"> 3693</span> : #endif // C++20</span>
<span id="L3694"><span class="lineNum"> 3694</span> : </span>
<span id="L3695"><span class="lineNum"> 3695</span> : _GLIBCXX_END_NAMESPACE_VERSION</span>
<span id="L3696"><span class="lineNum"> 3696</span> : } // namespace</span>
<span id="L3697"><span class="lineNum"> 3697</span> : </span>
<span id="L3698"><span class="lineNum"> 3698</span> : #if _GLIBCXX_USE_STD_SPEC_FUNCS</span>
<span id="L3699"><span class="lineNum"> 3699</span> : # include &lt;bits/specfun.h&gt;</span>
<span id="L3700"><span class="lineNum"> 3700</span> : #endif</span>
<span id="L3701"><span class="lineNum"> 3701</span> : </span>
<span id="L3702"><span class="lineNum"> 3702</span> : } // extern &quot;C++&quot;</span>
<span id="L3703"><span class="lineNum"> 3703</span> : </span>
<span id="L3704"><span class="lineNum"> 3704</span> : #endif</span>
</pre>
</td>
</tr>
</table>
<br>
<table width="100%" border=0 cellspacing=0 cellpadding=0>
<tr><td class="ruler"><img src="../../../../glass.png" width=3 height=3 alt=""></td></tr>
<tr><td class="versionInfo">Generated by: <a href="https://github.com//linux-test-project/lcov" target="_parent">LCOV version 2.0-1</a></td></tr>
</table>
<br>
</body>
</html>
Reference in New Issue Copy Permalink