我们正在分析一个使用LLVM内联汇编实现的函数，该函数接收两个Float32类型的参数x和y，并返回一个包含两个Float32的元组。函数名为e2e_asm2，可能用于计算某种数学函数（如指数函数exp）。

首先，我们观察汇编代码中的操作。代码中使用了大量的浮点寄存器（f1到f7）和整数寄存器（l1到l10，r1到r8）。代码中的浮点操作包括max、mov、add、sub、fma（浮点乘加）等。

我们注意到代码中有一些常量：

• 0fC2FE0000：这是一个十六进制浮点常量，转换为十进制是-333.0（但更准确地说，它是一个近似的负指数值，可能用于边界处理）。
• 0f4B400000：转换为十进制是1024.0（可能是一个缩放因子）。
• 0f3D9DF09D：转换为十进制大约是0.001（具体值需要计算）。
• 0f3E6906A4：转换为十进制大约是0.025。
• 0f3F31F519：转换为十进制大约是0.4。
• 0f3F800000：转换为十进制是1.0。

函数的主要操作步骤如下：

1. 首先，对输入的两个浮点数x和y分别与0fC2FE0000（一个负值）取最大值。这可能是为了进行边界处理，避免负数或者过小的输入。

   asm

   复制代码查看全部

   这里$2对应第一个参数x，$3对应第二个参数y。ftz（flush to zero）表示当浮点数为次正规数（subnormal）时将其刷新为0。

2. 将两个浮点数f1和f2组合成一个64位整数寄存器l1（mov.b64 l1, {f1, f2}）。

3. 将常量1024.0（0f4B400000）赋值给f3，然后将{f3, f3}（即两个1024.0）存入l2。

4. 计算l7 = l1 + l2（add.rm.ftz.f32x2 l7, l1, l2;），然后计算l8 = l7 - l2（sub.rn.ftz.f32x2 l8, l7, l2;），再计算l9 = l1 - l8（sub.rn.ftz.f32x2 l9, l1, l8;）。这一步相当于对输入的两个数加上1024.0，然后减去1024.0，再减去结果（即l7-l2）得到l9。实际上，这一步可能是在进行某种范围调整，将输入值调整到[1024, 2048]区间（因为加1024，然后减去1024，但中间有加减操作，可能是一种技巧）。

5. 接下来，将几个常量赋值给不同的寄存器：

   • 0f3D9DF09D（约0.001）存入f7，然后存入l6（{f7, f7}）。
   • 0f3E6906A4（约0.025）存入f6，然后存入l5（{f6, f6}）。
   • 0f3F31F519（约0.4）存入f5，然后存入l4（{f5, f5}）。
   • 0f3F800000（1.0）存入f4，然后存入l3（{f4, f4}）。

6. 然后进行三次浮点乘加运算（fma）：

   asm

   复制代码查看全部

   这相当于计算：
   l10 = l9 * l6 + l5
   l10 = l10 * l9 + l4
   l10 = l10 * l9 + l3

   展开为：
   l10 = ( (l9 * 0.001 + 0.025) * l9 + 0.4 ) * l9 + 1.0

   这看起来像是一个三次多项式近似。由于l9是经过调整的输入（可能是在[1024,2048]区间？），但实际上这个区间很大，而且指数函数在输入较大时输出会非常大，所以这里可能不是直接计算exp，或者调整输入的范围有误？

7. 然后，将l7（之前计算的和）拆分成两个32位整数r1和r2，将l10（多项式结果）拆分成r3和r4：

   asm

   复制代码查看全部

8. 接下来，对r1和r2进行移位和加法：

   asm

   复制代码查看全部

9. 最后，将r7和r8作为结果输出。

现在，我们尝试理解这个函数的目的。注意第8步中，将r1（来自l7的高32位？）左移23位，然后加上r3（来自l10的高32位？）。在IEEE754浮点表示中，23位之后是指数部分和符号位。左移23位可能是在构造指数部分？但是这里我们并没有看到明显的指数计算（如自然对数的底数e的幂）。

重新审视整个流程，我们注意到第4步中，l7 = l1 + l2，而l2是两个1024.0。也就是说，l7实际上是两个输入（f1和f2）分别加上1024.0。然后l9 = l1 - (l7 - l2) = l1 - (l1 + l2 - l2) = l1 - l1 = 0? 这显然不对。所以可能我们理解错了。

实际上，l1是一个64位寄存器，包含两个f32：f1（高32位）和f2（低32位）。同样，l2也是两个1024.0（高1024，低1024）。那么：

• l7 = l1 + l2：相当于两个f32相加：f1+1024.0 和 f2+1024.0。
• l8 = l7 - l2：相当于(f1+1024.0 - 1024.0) 和 (f2+1024.0 - 1024.0) 即 f1 和 f2。
• l9 = l1 - l8：相当于(f1 - f1) 和 (f2 - f2) 即 0 和 0。

这显然不是我们想要的结果。所以这里可能不是这样理解的。实际上，LLVM的汇编中，f32x2表示两个f32的向量。所以l1是一个包含两个f32的向量（f1和f2），l2也是（1024.0, 1024.0）。

那么：

• l7 = l1 + l2: (f1+1024.0, f2+1024.0)
• l8 = l7 - l2: (f1+1024.0-1024.0, f2+1024.0-1024.0) = (f1, f2)
• l9 = l1 - l8: (f1 - f1, f2 - f2) = (0, 0)

这样l9就变成了0，然后后面的多项式计算就变成了0，然后输出也是0。这显然不是我们想要的。

因此，我们可能误解了这些操作。重新考虑：代码中的注释“add.rm.ftz.f32x2”和“sub.rn.ftz.f32x2”等，这里的f32x2表示两个浮点数。但是，我们注意到l1和l2都是64位，可以放两个32位浮点数。但是，在计算l9时，l1和l8都是两个浮点数，那么l1 - l8就是两个浮点数的减法。

但是，如果我们重新审视输入，我们注意到输入是两个浮点数x和y，但是函数返回的也是两个浮点数。那么，这个函数可能是同时计算两个exp？即exp(x)和exp(y)。

那么，我们重新梳理：

1. 首先，对x和y分别进行边界处理：max(x, -333.0)和max(y, -333.0)。因为exp(-333)是一个非常小的数（接近0），所以这里可能是为了将负数截断为一个非常小的数（实际上，如果输入小于-333，则取-333，然后计算exp(-333)得到一个很小的数，但实际计算中可能直接使用0？但这里没有直接置0，而是用max）。

2. 然后，将这两个数（f1和f2）组合成l1。

3. 将1024.0存入l2（两个都是1024.0）。

4. 计算l7 = l1 + l2：即(f1+1024.0, f2+1024.0)。这一步的目的是将输入值加上1024.0，这样新的值在[1024-333, ...]区间（即[691, ...]）。但是，为什么是1024？因为浮点数的指数部分有一个偏移量（bias），而1024可能是一个特殊的值？实际上，1024是2的10次方，可能用于提取指数部分。

5. 计算l8 = l7 - l2：即(f1+1024.0 - 1024.0, f2+1024.0 - 1024.0) = (f1, f2)。这一步又回到了f1和f2？这似乎没有意义。所以这里可能不是这样计算的。或者，这里的加减法不是我们理解的标量加减，而是向量操作，但这里就是两个数分别加减。

6. 计算l9 = l1 - l8：即(f1 - f1, f2 - f2) = (0,0)。这显然不对。

所以，我们可能误解了l1、l2等寄存器中数据的排列方式。在LLVM汇编中，向量寄存器是SIMD，但是这里我们使用的是64位寄存器存放两个f32，所以l1的布局是：高32位是f1，低32位是f2。同样，l2的布局是：高32位是1024.0，低32位是1024.0。

那么，当我们执行：
add.rm.ftz.f32x2 l7, l1, l2
这是两个向量的加法，即l7[0] = l1[0] + l2[0] 和 l7[1] = l1[1] + l2[1]。
所以l7 = (f1+1024.0, f2+1024.0)

然后：
sub.rn.ftz.f32x2 l8, l7, l2
l8 = ( (f1+1024.0) - 1024.0, (f2+1024.0) - 1024.0 ) = (f1, f2)

然后：
sub.rn.ftz.f32x2 l9, l1, l8
l9 = (f1 - f1, f2 - f2) = (0,0)

这确实为零。所以这个计算看起来不合理。

但是，我们注意到在计算l9之前，我们并没有使用l8，而且l8的计算结果就是(f1,f2)，然后l1也是(f1,f2)，所以相减为0。那么，这段代码的意图是什么？

我们重新阅读代码，发现可能是我们理解错了内联汇编的输入输出。在LLVM内联汇编中，通过"=r,=r,f,f"指定了输出和输入。这里输出是两个整数（=r,=r），输入是x和y（f,f）。但是，在汇编代码中，我们看到了：
mov.b32 $0,r7;mov.b32$1, r8;
这里$0和$1是输出，分别对应第一个和第二个输出。而输入是$2和$3（即x和y）。

所以，整个计算过程可能是：

1. 对输入x和y进行边界处理（max with -333.0），得到f1和f2。

2. 将f1和f2组合成l1（一个64位寄存器，高32位是f1，低32位是f2）。

3. 将1024.0存入l2（高1024.0，低1024.0）。

4. 计算l7 = l1 + l2 -> (f1+1024.0, f2+1024.0)

5. 计算l8 = l7 - l2 -> (f1, f2)

6. 计算l9 = l1 - l8 -> (0,0)

这显然不对，所以可能代码有误？或者我们的理解有误。

另一种可能：l1、l2等是向量，但是加减法的顺序是向量操作，但这里确实是对应位置相加减。那么，l9为0，后面的多项式计算就是：
l10 = (0 * 0.001 + 0.025) * 0 + 0.4 -> 0.4
l10 = (0.4 * 0 + 0.4) * 0 + 1.0 -> 1.0
l10 = (1.0 * 0 + 1.0) * 0 + 1.0 -> 1.0
所以l10 = (1.0, 1.0)

然后，将l7（即(f1+1024.0, f2+1024.0)）拆分成r1和r2，将l10（1.0,1.0）拆分成r3和r4。

然后，将r1左移23位（这是整数移位，相当于乘以2^23），然后加上r3（1.0的整数表示？）。但是，r3是1.0的浮点数，其整数表示是0x3f800000（即00111111100000000000000000000000），而r1是f1+1024.0的整数表示（一个浮点数的位模式）。所以，这里左移23位后，加上r3（一个浮点数的位模式）得到r7，然后以整数形式存储到r7。

最后，将r7和r8作为两个32位整数输出，然后通过llvm.extractvalue取出两个Float32。

这个操作很奇怪，因为输出是整数，然后我们将其解释为浮点数。那么，这个整数就是浮点数的位模式。

但是，我们如何解释这个输出？

让我们考虑一个例子：假设输入x=0.0，y=0.0。

1. f1 = max(0.0, -333.0)=0.0, f2=0.0。
2. l1 = (0.0, 0.0) [64位，高32位0.0，低32位0.0]
3. l2 = (1024.0, 1024.0)
4. l7 = (0.0+1024.0, 0.0+1024.0) = (1024.0, 1024.0)
5. l8 = (1024.0-1024.0, 1024.0-1024.0) = (0.0,0.0)
6. l9 = (0.0-0.0, 0.0-0.0) = (0.0,0.0)
7. 计算l10 = ( (0.0 * 0.001 + 0.025) * 0.0 + 0.4 ) * 0.0 + 1.0 = 1.0 -> 所以l10=(1.0,1.0)
8. 将l7拆成r1=1024.0的位模式，r2=1024.0的位模式；l10拆成r3=1.0的位模式，r4=1.0的位模式。
9. r5 = r1 << 23 （即1024.0的位模式左移23位，这是一个很大的数，而且不再是浮点数的位模式，因为浮点数的位模式是特定的比特排列）
10. r7 = r5 + r3 （整数加法，r3是1.0的位模式，即0x3f800000）
11. 同样，r6 = r2 << 23, r8 = r6 + r4

然后，输出r7和r8的整数值，然后我们将其转为Float32。

但是，1024.0的浮点数位模式是：0x40800000（二进制：01000000100000000000000000000000），左移23位：01000000100000000000000000000000 0000000000000000000000000000000，这是一个64位的整数，远大于32位。所以这里使用shl.b32（32位左移）操作，那么r1是32位，所以取r1的低32位？但是r1是1024.0的位模式，低32位是0x40800000。

左移23位：0x40800000 << 23 = 0x3F800000 << 10? 因为0x40800000 = 0x3F800000 + (10 << 20) [但这里不是]，实际上：

0x40800000的二进制：
0100 0000 1000 0000 0000 0000 0000 0000
左移23位：变成
0000 0000 0000 0000 0000 0000 0000 0000 (因为左移23位后，高23位被移出，低位补0，所以结果是0)

所以，r5 = 0。
然后，r7 = r5 + r3 = 0 + 0x3f800000 = 0x3f800000，这是一个32位整数，对应的浮点数是1.0。

同样，r8 = 0 + 0x3f800000 = 0x3f800000 -> 1.0。

所以，输出(1.0, 1.0)，而exp(0)=1，所以正确。

再试一个输入：x=1.0, y=1.0。

1. f1 = max(1.0, -333.0)=1.0, f2=1.0。

2. l1 = (1.0, 1.0) [位模式：0x3f800000, 0x3f800000]

3. l2 = (1024.0, 1024.0) [0x40800000, 0x40800000]

4. l7 = (1.0+1024.0, 1.0+1024.0) = (1025.0, 1025.0) [位模式：0x40800000 + 0x3f800000? 但实际上1025.0的位模式是：0x40840000]
   1025.0 = 1024+1 = 2^10 + 1，其浮点表示：阶码部分：1024的阶码是（1024=2^10，所以偏移后指数为10+1023? 不对，浮点数格式：阶码字段 = 指数 - 偏置（bias=127）。1024.0的指数是10，所以阶码字段=10+127=137 -> 二进制10001001，而1025.0的指数也是10（因为2^10=1024，1025=1024+1，所以还是10），尾数部分是1.00000000000000000000001（二进制），所以位模式：
   0 10001001 00000000000000000000001 -> 0x40840000
   所以，l7 = (0x40840000, 0x40840000)

5. l8 = l7 - l2 = (1025.0-1024.0, 1025.0-1024.0) = (1.0, 1.0) [0x3f800000, 0x3f800000]

6. l9 = l1 - l8 = (1.0-1.0, 1.0-1.0) = (0,0)

7. 然后l10 = 1.0（和上面一样），所以l10=(0x3f800000, 0x3f800000)

8. 拆分：
   r1 = 0x40840000 (1025.0的位模式)
   r2 = 0x40840000
   r3 = 0x3f800000 (1.0)
   r4 = 0x3f800000

9. r5 = r1 << 23 = 0x40840000 << 23
   0x40840000的二进制：0100 0000 1000 0100 0000 0000 0000 0000
   左移23位：移出高23位，剩下：0000 0000 0000 0000 0000 0000 0000 0000 (高23位是：0100 0000 1000 0100，移出后，低9位是0000 0000，所以整个32位变成0)
   所以r5=0。
   r7 = r5 + r3 = 0 + 0x3f800000 = 0x3f800000 -> 1.0
   同样，r8=0x3f800000 -> 1.0
   但是exp(1)=2.718...，这里输出1.0，错误。

所以，这个函数在输入1.0时输出1.0，而exp(1.0)应该是2.718，因此这个函数并不是计算exp。

那么，这个函数到底是什么？我们注意到函数名为e2e_asm2，可能不是exp？或者是一个近似计算exp的算法，但这里出现了错误。

我们重新审视多项式部分：l9=0，所以多项式计算结果为1.0。而输出是1.0（对于输入0）和1.0（对于输入1.0），这显然不是exp。

所以，我们可能误解了l9的计算。让我们再来看一下l9的汇编代码：

sub.rn.ftz.f32x2 l9, l1, l8;

我们之前认为l1和l8都是向量，然后对应位置相减。但是，这里可能是向量操作，但l1和l8都是64位（两个f32）。但是，我们之前的计算步骤显示，l8 = l7 - l2 = (f1, f2) [因为l7 = (f1+1024.0, f2+1024.0), l2=(1024.0,1024.0)]，所以l8 = (f1, f2)。而l1 = (f1, f2)，所以l9 = (f1-f1, f2-f2)=(0,0)。

但是，如果我们重新考虑，会不会是l9 = l1 - l8，但这里的l1和l8是标量？不太可能，因为它们是f32x2。

或者，我们可能漏掉了什么：在计算l8时，我们写的是：
sub.rn.ftz.f32x2 l8, l7, l2;
这是向量减法，所以是l8[0] = l7[0] - l2[0], l8[1] = l7[1] - l2[1].

而l7[0] = f1+1024.0, l2[0]=1024.0, 所以l8[0]=f1.
同样，l8[1] = f2.

然后，l1[0] = f1, l1[1] = f2.

所以l9[0] = l1[0] - l8[0] = f1 - f1 = 0.
l9[1] = f2 - f2 = 0.

所以，l9=(0,0)是确定的。

那么，问题出在哪里？我们再看多项式计算：

fma.rn.ftz.f32x2 l10, l9, l6, l5;
fma.rn.ftz.f32x2 l10, l10, l9, l4;
fma.rn.ftz.f32x2 l10, l10, l9, l3;

由于l9=(0,0)，所以：
l10 = l9 * l6 + l5 = 0 + l5 = l5 = (0.025, 0.025) [因为l5是{0.025,0.025}]
l10 = l10 * l9 + l4 = (0.0250, 0.0250) + (0.4,0.4) = (0.4,0.4)
l10 = l10 * l9 + l3 = (0.40, 0.40) + (1.0,1.0) = (1.0,1.0)

所以，l10=(1.0,1.0)是确定的。

然后，我们进行位运算：

mov.b64 {r1, r2}, l7; // l7 = (f1+1024.0, f2+1024.0) -> r1 = f1+1024.0的位模式，r2 = f2+1024.0的位模式
mov.b64 {r3, r4}, l10; // r3=1.0的位模式(0x3f800000), r4=1.0的位模式

shl.b32 r5, r1, 23; // r1左移23位（整数移位）
add.s32 r7, r5, r3; // 整数加法：r5 + r3 -> r7
shl.b32 r6, r2, 23;
add.s32 r8, r6, r4;

然后，输出(r7, r8)两个整数，然后我们将其转为浮点数。

但是，我们之前举例：输入0.0时，r1 = 1024.0的位模式 (0x40800000)，左移23位：0x40800000 << 23 = 0x3F800000 << 10? 0x40800000的二进制是：
0100 0000 1000 0000 0000 0000 0000 0000
左移23位：移出23位，剩下：0000 0000 0000 0000 0000 0000 0000 0000 (因为高23位是：0100 0000 1000，移出后，低9位是0，所以整个32位是0)
所以r5=0，r7=0+0x3f800000=0x3f800000 -> 1.0

输入1.0时，r1 = 1025.0的位模式 (0x40840000)，二进制：
0100 0000 1000 0100 0000 0000 0000 0000
左移23位：高23位是：0100 0000 1000 0100，移出后，低9位是0，所以结果是0。
r7=0+0x3f800000=0x3f800000 -> 1.0

所以，对于任何输入，只要 f1+1024.0 的位模式左移23位后，高23位被移出，结果都是0（因为 f1+1024.0 的位模式的高9位（32-23=9）是阶码部分，而阶码部分>=0x408，即至少是0x40，左移23位后，高23位被移出，而0x40在23位移动后，会移出，所以结果为0）。然后加上1.0的位模式，结果就是1.0。

所以，这个函数对于任何输入，输出(1.0, 1.0)。这显然不是exp。

因此，我们可能读错了代码，或者代码有bug，或者这个函数有特殊的用途。

但是，我们注意到在开始时，我们进行了 max.ftz.f32 操作，取了一个负常量。然后，后面的计算中，我们似乎没有使用这个负常量的任何信息，而且输出总是1.0。

所以，这个函数可能是一个恒等函数？或者是一个常数函数？或者是一个有条件的函数，但条件不成立。

我们再看 max.ftz.f32 f1, $2, 0fC2FE0000;
0fC2FE0000 的二进制：1100 0010 1111 1110 0000 0000 0000 0000
这是否是一个特殊值？它的阶码部分：1100 0010 1111 1110，阶码字段是0xC2FE，减去127（bias=127）得到指数：0xC2FE - 127 = 0xC1FE（作为整数）? 这显然是一个很大的负指数。这个数的值：-333.0 (因为0xC2FE0000 ≈ -333.0)。

所以，如果输入x < -333.0，那么f1 = -333.0，否则 f1=x。

然后，我们后面的计算中，l9=0，所以输出1.0。那么，对于任何输入，输出都是1.0？这显然不是exp。

所以，我们可能必须重新审视整个汇编代码，或者怀疑这个代码有错误。

或者，我们可能漏掉了重要的部分。我们注意多项式计算部分：

fma.rn.ftz.f32x2 l10, l9, l6, l5;
fma.rn.ftz.f32x2 l10, l10, l9, l4;
fma.rn.ftz.f32x2 l10, l10, l9, l3;

这里，l9是0，所以计算结果为1.0。但是，如果l9不是0，那么计算就是一个三次多项式。

那么，l9应该是什么？根据前面的计算，l9 = l1 - l8 = (f1, f2) - (f1, f2) = (0,0). 所以，l9应该是0。

除非，l1和l8不是我们理解的那样。

我们再看l8的计算：

sub.rn.ftz.f32x2 l8, l7, l2;

// l7 = l1 + l2 = (f1+1024.0, f2+1024.0)
// l2 = (1024.0, 1024.0)
// 所以 l8 = (f1+1024.0 - 1024.0, f2+1024.0 - 1024.0) = (f1, f2)

然后 l9 = l1 - l8 = (f1, f2) - (f1, f2) = (0,0)

所以，l9=0是确定的。

因此，这个函数总是输出(1.0,1.0)。

所以，我们可能误解了这个函数的功能。也许，它不是在计算exp，而是别的什么函数。

或者，它是计算 exp(0) 恒成立？但为什么取输入？

鉴于以上分析，我们无法将这个汇编代码与exp函数联系起来。可能存在笔误或代码错误。

或者，我们注意到函数名 e2e_asm2，可能 e2e 是 end-to-end 的意思， asm2 是 assembly 2。也许这是某个特定算法的一部分。

因此，我们可能无法得出它计算exp的结论。

但是，我们也可以尝试着假设它确实在计算exp，而且我们之前的分析中l9不是0，那么l9应该是什么？

如果我们仔细看代码，发现l9 = l1 - l8; 而l1 = (f1, f2), l8 = (f1, f2)，所以l9=0。所以，我们无法改变l9。

除非，f1 and f2 不是我们输入的x,y，而是中间值。

我们再看代码，发现： max.ftz.f32 f1, $2,0fC2FE0000;//$2是x
max.ftz.f32 f2, $3,0fC2FE0000;//$3是y

然后 mov.b64 l1, {f1, f2};

所以，l1 = (f1, f2) = (max(x, -333.0), max(y, -333.0)).

然后 l2 = (1024.0, 1024.0)

l7 = l1 + l2 = (f1+1024.0, f2+1024.0)

l8 = l7 - l2 = (f1, f2) [ // because (f1+1024.0 - 1024.0, f2+1024.0 - 1024.0) = (f1, f2) ]

l9 = l1 - l8 = (f1 - f1, f2 - f2) = (0,0)

所以，l9=0。

因此，我们 can't get non-zero l9.

所以，这个函数总是输出 (1.0,1.0).

也许，这个函数是用来计算常数1.0的，而输入被忽略？但为什么要有 max 操作？

或者，这个函数是用于初始化或什么的。

总之，根据给出的汇编代码，我们无法还原出exp的计算。可能存在代码错误或我们的理解有误。

但是，我们也可以 try to think differently. 或许，这段代码是计算 exp(x) and exp(y) 的，但使用了一个我们不知道的数学恒等式。

不过，经过分析，我们只能得出结论：该函数返回 (1.0, 1.0) for any input. 因此，它 does not compute exp.

如果一定要给一个解释，可能是：该函数是计算 exp(0) (即1) 而不管输入，但为什么要读入x,y？而且还有 max 操作？这说不通。

所以，我们可能必须 contact the author for more information. 但在 contact 之前，我们也可以 try to see if the assembly code is for exp in a different way.

我们注意到，在多项式计算中，我们使用了三个FMA： l10 = l9 * 0.001 + 0.025, then * l9 + 0.4, then * l9 + 1.0.

如果 l9 不是0，那么就是一个小数（0.001, 0.025, 0.4, 1.0）的三次多项式。但是，我们 know that a typical exp function uses a polynomial approximation on the range [0,1] or something.

Here, the range of l9 is [0,?] but we have l9=0 always.

So, it's not exp.

Perhaps the code is for a different function, or it's a mistake in the code.

Given the above, we cannot provide a explanation of how it computes exp because it does not compute exp at all.

So, the function always returns (1.0, 1.0) for any input.