## OpenJDK / jdk / jdk

### changeset 50366:4d85990f9c4a

8202812: [TESTBUG] Open source VM testbase compiler tests
Reviewed-by: kvn, mseledtsov

line wrap: on

line diff

--- a/test/hotspot/jtreg/ProblemList.txt Fri Jun 01 15:24:41 2018 -0700 +++ b/test/hotspot/jtreg/ProblemList.txt Fri Jun 01 15:48:55 2018 -0700 @@ -148,6 +148,9 @@ vmTestbase/gc/lock/jni/jnilock002/TestDescription.java 8191869,8192647 generic-all +vmTestbase/jit/escape/LockCoarsening/LockCoarsening001/TestDescription.java 8148743 generic-all +vmTestbase/jit/escape/LockCoarsening/LockCoarsening002/TestDescription.java 8079666 generic-all + vmTestbase/vm/mlvm/indy/func/jdi/breakpointOtherStratum/Test.java 8199578 generic-all vmTestbase/vm/mlvm/indy/func/jdi/breakpoint/Test.java 8199578 generic-all vmTestbase/vm/mlvm/indy/func/jvmti/redefineClassInBootstrap/TestDescription.java 8013267 generic-all

--- a/test/hotspot/jtreg/TEST.ROOT Fri Jun 01 15:24:41 2018 -0700 +++ b/test/hotspot/jtreg/TEST.ROOT Fri Jun 01 15:48:55 2018 -0700 @@ -27,7 +27,7 @@ # It also contains test-suite configuration information. # The list of keywords supported in this test suite -keys=cte_test jcmd nmt regression gc stress metaspace +keys=cte_test jcmd nmt regression gc stress metaspace headful groups=TEST.groups

--- a/test/hotspot/jtreg/TEST.groups Fri Jun 01 15:24:41 2018 -0700 +++ b/test/hotspot/jtreg/TEST.groups Fri Jun 01 15:48:55 2018 -0700 @@ -1971,6 +1971,293 @@ vmTestbase/metaspace/shrink_grow/ShrinkGrowMultiJVM/ShrinkGrowMultiJVM.java \ vmTestbase/metaspace/shrink_grow/CompressedClassSpaceSize/TestDescription.java +# Just-In-Time compiler tests +vmTestbase_vm_compiler = \ + vmTestbase/vm/compiler \ + vmTestbase/jit \ + vmTestbase/vm/jit + +vmTestbase_vm_compiler_quick = \ + vmTestbase/vm/compiler/jbe/constprop/constprop01/constprop01.java \ + vmTestbase/vm/compiler/jbe/constprop/constprop02/constprop02.java \ + vmTestbase/vm/compiler/jbe/dead/dead01/dead01.java \ + vmTestbase/vm/compiler/jbe/dead/dead02/dead02.java \ + vmTestbase/vm/compiler/jbe/dead/dead03/dead03.java \ + vmTestbase/vm/compiler/jbe/dead/dead04/dead04.java \ + vmTestbase/vm/compiler/jbe/dead/dead05/dead05.java \ + vmTestbase/vm/compiler/jbe/dead/dead06/dead06.java \ + vmTestbase/vm/compiler/jbe/dead/dead07/dead07.java \ + vmTestbase/vm/compiler/jbe/dead/dead08/dead08.java \ + vmTestbase/vm/compiler/jbe/dead/dead09/dead09.java \ + vmTestbase/vm/compiler/jbe/dead/dead10/dead10.java \ + vmTestbase/vm/compiler/jbe/dead/dead11/dead11.java \ + vmTestbase/vm/compiler/jbe/dead/dead12/dead12.java \ + vmTestbase/vm/compiler/jbe/dead/dead13/dead13.java \ + vmTestbase/vm/compiler/jbe/dead/dead14/dead14.java \ + vmTestbase/vm/compiler/jbe/dead/dead15/dead15.java \ + vmTestbase/vm/compiler/jbe/dead/dead16/dead16.java \ + vmTestbase/vm/compiler/jbe/hoist/hoist01/hoist01.java \ + vmTestbase/vm/compiler/jbe/hoist/hoist02/hoist02.java \ + vmTestbase/vm/compiler/jbe/hoist/hoist03/hoist03.java \ + vmTestbase/vm/compiler/jbe/hoist/hoist04/hoist04.java \ + vmTestbase/vm/compiler/jbe/subcommon/subcommon01/subcommon01.java \ + vmTestbase/vm/compiler/jbe/subcommon/subcommon03/subcommon03.java \ + vmTestbase/vm/compiler/jbe/subcommon/subcommon04/subcommon04.java \ + vmTestbase/vm/compiler/jbe/subcommon/subcommon05/subcommon05.java \ + vmTestbase/vm/compiler/coverage/parentheses/TestDescription.java \ + vmTestbase/vm/compiler/optimizations/stringconcat/explicit/Explicit01/cs_disabled/TestDescription.java \ + vmTestbase/vm/compiler/optimizations/stringconcat/explicit/Explicit01/cs_enabled/TestDescription.java \ + vmTestbase/vm/compiler/optimizations/stringconcat/explicit/Merge01/cs_disabled/TestDescription.java \ + vmTestbase/vm/compiler/optimizations/stringconcat/explicit/Merge01/cs_enabled/TestDescription.java \ + vmTestbase/vm/compiler/optimizations/stringconcat/implicit/Implicit01/cs_disabled/TestDescription.java \ + vmTestbase/vm/compiler/optimizations/stringconcat/implicit/Implicit01/cs_enabled/TestDescription.java \ + vmTestbase/vm/compiler/optimizations/stringconcat/implicit/Merge01/cs_disabled/TestDescription.java \ + vmTestbase/vm/compiler/optimizations/stringconcat/implicit/Merge01/cs_enabled/TestDescription.java \ + vmTestbase/vm/compiler/optimizations/partialpeel/ForWhile/TestDescription.java \ + vmTestbase/vm/compiler/optimizations/partialpeel/While/TestDescription.java \ + vmTestbase/vm/compiler/optimizations/partialpeel/WhileWhile/TestDescription.java \ + vmTestbase/vm/compiler/optimizations/partialpeel/Do/TestDescription.java \ + vmTestbase/vm/compiler/complog/uninit/uninit001/uninit001.java \ + vmTestbase/vm/compiler/complog/uninit/uninit002/uninit002.java \ + vmTestbase/vm/compiler/complog/uninit/uninit003/uninit003.java \ + vmTestbase/vm/compiler/complog/uninit/uninit004/uninit004.java \ + vmTestbase/vm/compiler/complog/uninit/uninit005/uninit005.java \ + vmTestbase/vm/compiler/complog/uninit/uninit006/uninit006.java \ + vmTestbase/vm/compiler/complog/uninit/uninit007/uninit007.java \ + vmTestbase/vm/compiler/complog/uninit/uninit008/uninit008.java \ + vmTestbase/vm/compiler/complog/uninit/uninit009/uninit009.java \ + vmTestbase/vm/compiler/complog/uninit/uninit010/uninit010.java \ + vmTestbase/vm/compiler/complog/uninit/uninit011/uninit011.java \ + vmTestbase/vm/compiler/complog/uninit/uninit012/uninit012.java \ + vmTestbase/vm/compiler/complog/uninit/uninit013/uninit013.java \ + vmTestbase/jit/Arrays/ArrayBounds/ArrayBounds.java \ + vmTestbase/jit/Arrays/ArrayStoreCheck/ArrayStoreCheck.java \ + vmTestbase/jit/Arrays/ArrayTests/ArrayTests.java \ + vmTestbase/jit/CEETest/CEETest.java \ + vmTestbase/jit/CondExpr/CondExpr.java \ + vmTestbase/jit/DivTest/DivTest.java \ + vmTestbase/jit/ExcOpt/ExcOpt.java \ + vmTestbase/jit/FloatingPoint/FPCompare/TestFPBinop/TestFPBinop.java \ + vmTestbase/jit/FloatingPoint/gen_math/Filtering/Filtering.java \ + vmTestbase/jit/FloatingPoint/gen_math/Loops01/Loops01.java \ + vmTestbase/jit/FloatingPoint/gen_math/Loops02/Loops02.java \ + vmTestbase/jit/FloatingPoint/gen_math/Loops03/Loops03.java \ + vmTestbase/jit/FloatingPoint/gen_math/Loops04/Loops04.java \ + vmTestbase/jit/FloatingPoint/gen_math/Loops05/Loops05.java \ + vmTestbase/jit/FloatingPoint/gen_math/Loops06/Loops06.java \ + vmTestbase/jit/FloatingPoint/gen_math/Loops07/Loops07.java \ + vmTestbase/jit/FloatingPoint/gen_math/Matrix_3d/Matrix_3d.java \ + vmTestbase/jit/FloatingPoint/gen_math/ShortCircuitTest/ShortCircuitTest.java \ + vmTestbase/jit/FloatingPoint/gen_math/Summ/Summ.java \ + vmTestbase/jit/PrintProperties/PrintProperties.java \ + vmTestbase/jit/PrintThis/PrintThis.java \ + vmTestbase/jit/Robert/Robert.java \ + vmTestbase/jit/Sleeper/Sleeper.java \ + vmTestbase/jit/bounds/bounds.java \ + vmTestbase/jit/collapse/collapse.java \ + vmTestbase/jit/deoptimization/test01/test01.java \ + vmTestbase/jit/deoptimization/test02/test02.java \ + vmTestbase/jit/deoptimization/test03/test03.java \ + vmTestbase/jit/deoptimization/test04/test04.java \ + vmTestbase/jit/deoptimization/test05/test05.java \ + vmTestbase/jit/deoptimization/test06/test06.java \ + vmTestbase/jit/deoptimization/test07/test07.java \ + vmTestbase/jit/deoptimization/test08/test08.java \ + vmTestbase/jit/escape/AdaptiveBlocking/AdaptiveBlocking001/AdaptiveBlocking001.java \ + vmTestbase/jit/escape/LockElision/MatMul/MatMul.java \ + vmTestbase/jit/escape/LockCoarsening/LockCoarsening002/TestDescription.java \ + vmTestbase/jit/exception/exception.java \ + vmTestbase/jit/graph/cgt0/cgt0.java \ + vmTestbase/jit/graph/cgt1/cgt1.java \ + vmTestbase/jit/graph/cgt2/cgt2.java \ + vmTestbase/jit/graph/cgt3/cgt3.java \ + vmTestbase/jit/graph/cgt4/cgt4.java \ + vmTestbase/jit/graph/cgt5/cgt5.java \ + vmTestbase/jit/graph/cgt6/cgt6.java \ + vmTestbase/jit/graph/cgt7/cgt7.java \ + vmTestbase/jit/graph/cgt8/cgt8.java \ + vmTestbase/jit/graph/cgt9/cgt9.java \ + vmTestbase/jit/graph/cgt10/cgt10.java \ + vmTestbase/jit/graph/cgt11/cgt11.java \ + vmTestbase/jit/init/init01/init01.java \ + vmTestbase/jit/init/init02/init02.java \ + vmTestbase/jit/inline/inline003/inline003.java \ + vmTestbase/jit/inline/inline004/inline004.java \ + vmTestbase/jit/inline/inline005/inline005.java \ + vmTestbase/jit/inline/inline007/inline007.java \ + vmTestbase/jit/misctests/JitBug1/JitBug1.java \ + vmTestbase/jit/misctests/Pi/Pi.java \ + vmTestbase/jit/misctests/clss14702/clss14702.java \ + vmTestbase/jit/misctests/fpustack/GraphApplet.java \ + vmTestbase/jit/misctests/putfield00802/putfield00802.java \ + vmTestbase/jit/misctests/t5/t5.java \ + vmTestbase/jit/overflow/overflow.java \ + vmTestbase/jit/regression/b4427606/b4427606.java \ + vmTestbase/jit/regression/b4446672/b4446672.java \ + vmTestbase/jit/regression/CrashC1/CrashC1.java \ + vmTestbase/jit/series/series.java \ + vmTestbase/jit/t/t001/t001.java \ + vmTestbase/jit/t/t002/t002.java \ + vmTestbase/jit/t/t003/t003.java \ + vmTestbase/jit/t/t004/t004.java \ + vmTestbase/jit/t/t005/t005.java \ + vmTestbase/jit/t/t006/t006.java \ + vmTestbase/jit/t/t007/t007.java \ + vmTestbase/jit/t/t008/t008.java \ + vmTestbase/jit/t/t009/t009.java \ + vmTestbase/jit/t/t011/t011.java \ + vmTestbase/jit/t/t012/t012.java \ + vmTestbase/jit/t/t013/t013.java \ + vmTestbase/jit/t/t014/t014.java \ + vmTestbase/jit/t/t015/t015.java \ + vmTestbase/jit/t/t016/t016.java \ + vmTestbase/jit/t/t017/t017.java \ + vmTestbase/jit/t/t018/t018.java \ + vmTestbase/jit/t/t019/t019.java \ + vmTestbase/jit/t/t020/t020.java \ + vmTestbase/jit/t/t021/t021.java \ + vmTestbase/jit/t/t022/t022.java \ + vmTestbase/jit/t/t023/t023.java \ + vmTestbase/jit/t/t024/t024.java \ + vmTestbase/jit/t/t025/t025.java \ + vmTestbase/jit/t/t026/t026.java \ + vmTestbase/jit/t/t027/t027.java \ + vmTestbase/jit/t/t028/t028.java \ + vmTestbase/jit/t/t029/t029.java \ + vmTestbase/jit/t/t030/t030.java \ + vmTestbase/jit/t/t031/t031.java \ + vmTestbase/jit/t/t032/t032.java \ + vmTestbase/jit/t/t033/t033.java \ + vmTestbase/jit/t/t034/t034.java \ + vmTestbase/jit/t/t035/t035.java \ + vmTestbase/jit/t/t036/t036.java \ + vmTestbase/jit/t/t037/t037.java \ + vmTestbase/jit/t/t038/t038.java \ + vmTestbase/jit/t/t039/t039.java \ + vmTestbase/jit/t/t040/t040.java \ + vmTestbase/jit/t/t041/t041.java \ + vmTestbase/jit/t/t042/t042.java \ + vmTestbase/jit/t/t043/t043.java \ + vmTestbase/jit/t/t044/t044.java \ + vmTestbase/jit/t/t045/t045.java \ + vmTestbase/jit/t/t046/t046.java \ + vmTestbase/jit/t/t047/t047.java \ + vmTestbase/jit/t/t048/t048.java \ + vmTestbase/jit/t/t049/t049.java \ + vmTestbase/jit/t/t050/t050.java \ + vmTestbase/jit/t/t051/t051.java \ + vmTestbase/jit/t/t052/t052.java \ + vmTestbase/jit/t/t053/t053.java \ + vmTestbase/jit/t/t054/t054.java \ + vmTestbase/jit/t/t055/t055.java \ + vmTestbase/jit/t/t056/t056.java \ + vmTestbase/jit/t/t057/t057.java \ + vmTestbase/jit/t/t058/t058.java \ + vmTestbase/jit/t/t059/t059.java \ + vmTestbase/jit/t/t060/t060.java \ + vmTestbase/jit/t/t061/t061.java \ + vmTestbase/jit/t/t062/t062.java \ + vmTestbase/jit/t/t063/t063.java \ + vmTestbase/jit/t/t064/t064.java \ + vmTestbase/jit/t/t065/t065.java \ + vmTestbase/jit/t/t066/t066.java \ + vmTestbase/jit/t/t067/t067.java \ + vmTestbase/jit/t/t068/t068.java \ + vmTestbase/jit/t/t069/t069.java \ + vmTestbase/jit/t/t070/t070.java \ + vmTestbase/jit/t/t071/t071.java \ + vmTestbase/jit/t/t072/t072.java \ + vmTestbase/jit/t/t073/t073.java \ + vmTestbase/jit/t/t074/t074.java \ + vmTestbase/jit/t/t075/t075.java \ + vmTestbase/jit/t/t076/t076.java \ + vmTestbase/jit/t/t077/t077.java \ + vmTestbase/jit/t/t078/t078.java \ + vmTestbase/jit/t/t079/t079.java \ + vmTestbase/jit/t/t080/t080.java \ + vmTestbase/jit/t/t081/t081.java \ + vmTestbase/jit/t/t086/t086.java \ + vmTestbase/jit/t/t087/t087.java \ + vmTestbase/jit/t/t088/t088.java \ + vmTestbase/jit/t/t091/t091.java \ + vmTestbase/jit/t/t093/t093.java \ + vmTestbase/jit/t/t094/t094.java \ + vmTestbase/jit/t/t095/t095.java \ + vmTestbase/jit/t/t096/t096.java \ + vmTestbase/jit/t/t098/t098.java \ + vmTestbase/jit/t/t099/t099.java \ + vmTestbase/jit/t/t100/t100.java \ + vmTestbase/jit/t/t101/t101.java \ + vmTestbase/jit/t/t102/t102.java \ + vmTestbase/jit/t/t103/t103.java \ + vmTestbase/jit/t/t104/t104.java \ + vmTestbase/jit/t/t105/t105.java \ + vmTestbase/jit/t/t106/t106.java \ + vmTestbase/jit/t/t107/t107.java \ + vmTestbase/jit/t/t108/TestDescription.java \ + vmTestbase/jit/t/t109/TestDescription.java \ + vmTestbase/jit/t/t110/TestDescription.java \ + vmTestbase/jit/t/t111/TestDescription.java \ + vmTestbase/jit/t/t112/TestDescription.java \ + vmTestbase/jit/t/t113/TestDescription.java \ + vmTestbase/jit/tiered/TestDescription.java \ + vmTestbase/jit/verifier/VerifyInitLocal/VerifyInitLocal.java \ + vmTestbase/jit/verifier/VerifyMergeStack/VerifyMergeStack.java \ + vmTestbase/jit/wide/wide01/wide01.java \ + vmTestbase/jit/wide/wide02/wide02.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc1/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc2/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc3/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc4/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc5/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc6/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc7/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc8/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc9/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc10/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc11/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc12/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc13/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc14/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc15/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc16/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc17/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc18/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc19/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc20/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc21/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc22/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc23/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc24/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc25/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc26/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc27/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc28/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc29/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc30/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc31/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc32/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc33/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc34/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc35/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc36/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc37/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc38/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc39/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc40/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc41/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc42/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc43/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc44/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc45/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc46/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc47/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc48/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc49/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc50/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc51/TestDescription.java \ + vmTestbase/vm/jit/LongTransitions/nativeFnc52/TestDescription.java + # JSR292 tests (invokedynamic AKA Multi-Language VM AKA Da Vinci Machine) vmTestbase_vm_mlvm = \ vmTestbase/vm/mlvm

--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/jit/Arrays/ArrayBounds/ArrayBounds.java Fri Jun 01 15:48:55 2018 -0700 @@ -0,0 +1,240 @@ +/* + * Copyright (c) 2008, 2018, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + * @test + * + * @summary converted from VM Testbase jit/Arrays/ArrayBounds. + * VM Testbase keywords: [jit, quick] + * + * @library /vmTestbase + * /test/lib + * @run driver jdk.test.lib.FileInstaller . . + * @run main/othervm jit.Arrays.ArrayBounds.ArrayBounds + */ + +package jit.Arrays.ArrayBounds; + +/* +SCCS ID : @(#)ArrayBounds.java 1.2 02/07/16 +*/ +/* The intent of this Java program is to expose Virtual Machines that + make illegal array bounds check removal optimizations. */ + +/* There are a variety of potential semantic problems with array bounds + checking. + + One source of potential bounds-check problems is a compiler that + "hoist"s bounds checks outside of loops. This may either either + because an array access is loop invariant, or because the compiler + is clever enough to determine a loop-invariant "sufficient + condition" that guarantees the safety of the safety of one or more + accesses within the loop. + + While this is a good approach, it has a variety of possible + pitfalls: + + 1) If a hoisted test fails, you can't just raise a bounds-check + exception when the test fails; the loop may have had global + side effects before the exception was supposed to have been + raised. [prematureExceptionTest] + + 2) A hoisted test may itself generate an exception (such as a + null pointer exception). Again, this must not be reflected + prematurely if the loop has global side effects that should be + observed. + + 3) An implementation might fail to be conservative enough about + the possible side effects of a method call within the loop. + For example, when an array being accessed within a loop is + accessed as a static or instance variable, then any call must + be assumed to possibly modify the array variable itself (in + the absence of pretty clever proof techniques!) So no hoisted + predicate mentioning the array length (as most will) can be + loop-invariant. + + 4) In some implementations, the code generated for a bounds-check + implicitly does a null check as well. For example, it may + access an array length field in the object header. On systems + where the 0-th page is protected, this might ensure an OS + signal for a null array pointer. But if a bounds check is + elided, the generated code might only access the null pointer + at a large offset, beyond the protected page, and fail to + produce a null pointer exception. + + 5) Multi-dimensional arrays are annoying for bounds-check removal. + If a loop over "i" accesses "a[i][j]" (where "j" is invariant in + the loop, then "a[i]" is not loop-invariant; it changes every + iteration. Even if a two-dimensional array were "rectangular" + when a loop begins, nothing guarantees that another thread + won't update some "a[k]" during the loop. If the compiler + hoisted some bounds check comparing "j" to the presumed length + of all the "a[k]", and a shorter array were written to some + "a[k]" during the loop, then we might miss a necessary array + bounds exception. +*/ + +import nsk.share.TestFailure; + + +public class ArrayBounds { + private static int global; + + private static int[] aplIota(int n) { + int[] a = new int[n]; + for (int j = 0; j < n; j++) a[j] = j; + return a; + } + + private static int prematureExceptionWork(int[] a, int n) { + global = 0; + int sum = 0; + try { + for (int i = 0; i < n; i++) { + global++; sum += a[i]; + } + } catch (ArrayIndexOutOfBoundsException t) {} + return sum; + } + private static void prematureException() { + int[] a = aplIota(10); + int sum = prematureExceptionWork(a, 11); + if (global != 11 || sum != 45) { + throw new TestFailure("Premature exception test failed."); + } + } + + private static class Foo { + int[] a; + } + + private static int exceptionInHoistedPredWork(Foo f, int n) { + global = 0; + int sum = 0; + try { + for (int i = 0; i < n; i++) { + global++; sum += f.a[i]; + } + } catch (NullPointerException t) {} + return sum; + } + private static void exceptionInHoistedPred() { + int sum = exceptionInHoistedPredWork(null, 10); + if (global != 1 || sum != 0) { + throw new TestFailure("Premature exception test failed."); + } + } + + private static void changeLength(Foo f, int n) { + int[] a = aplIota(n); + f.a = a; + } + private static int arraySideEffectWork(Foo f, int n) { + int sum = 0; + try { + for (int i = 0; i < n; i++) { + sum += f.a[i]; + if (i == 0) changeLength(f, 5); + } + } catch (ArrayIndexOutOfBoundsException t) {} + return sum; + } + private static void arraySideEffect() { + int[] a = aplIota(10); + Foo f = new Foo(); f.a = a; + int sum = arraySideEffectWork(f, 10); + if (sum != 10) { + throw new TestFailure("Array side effect test failed (" + sum + ")"); + } + } + + private static boolean nullArrayWork(int[] a, int n) { + int sum = 0; + global = 0; + boolean x = false; + try { + for (int i = 0; i < n; i++) { + global++; sum += a[i]; + } + } catch (NullPointerException t) { + x = true; + } + return x; + } + private static void nullArray() { + /* 30000 should be larger than most pages sizes! */ + if (!nullArrayWork(null, 30000) || global != 1) { + throw new TestFailure("nullArray test failed."); + } + } + + private static int[][] aa = new int[10][20]; + static { + for (int i = 0; i < 10; i++) aa[i] = aplIota(20); + } + private static class ArrayMutator extends Thread { + int[][] aa; int newN; + ArrayMutator(int[][] aa, int newN) { + super(); + this.aa = aa; this.newN = newN; + } + public void run() { + aa[1] = aplIota(newN); + } + } + + private static int array2DWork(int[][] aa, int m, int n) { + int sum = 0; + global = 0; + try { + for (int i = 0; i < m; i++) { + for (int j = 0; j < n; j++) { + global++; sum += aa[i][j]; + if (i == 0 && j == 0) { + Thread t = new ArrayMutator(aa, n/2); + try { + t.start(); + t.join(); + } catch (InterruptedException x) {} + } + } + } + } catch (ArrayIndexOutOfBoundsException t) {} + return sum; + } + private static void array2D() { + int sum = array2DWork(aa, aa.length, aa[0].length); + if (sum != 19*20/2 + 9*10/2 || global != 20 + 10 + 1) { + throw new TestFailure("array2D test failed (sum = " + sum + + "; global = " + global + ")"); + } + } + + public static void main(String[] args) { + exceptionInHoistedPred(); + prematureException(); + arraySideEffect(); + nullArray(); + array2D(); + } +}

--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/jit/Arrays/ArrayStoreCheck/ArrayStoreCheck.java Fri Jun 01 15:48:55 2018 -0700 @@ -0,0 +1,66 @@ +/* + * Copyright (c) 2008, 2018, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +// A simple program checking whether ArrayStoreExceptions are thrown + + +/* + * @test + * + * @summary converted from VM Testbase jit/Arrays/ArrayStoreCheck. + * VM Testbase keywords: [jit, quick] + * + * @library /vmTestbase + * /test/lib + * @run driver jdk.test.lib.FileInstaller . . + * @run main/othervm jit.Arrays.ArrayStoreCheck.ArrayStoreCheck + */ + +package jit.Arrays.ArrayStoreCheck; + +import nsk.share.TestFailure; + +class A {} + +class B extends A {} + +public class ArrayStoreCheck { + + static void doit(A list[], A element) { + boolean caught = false; + try { + list[0] = element; + } catch (Exception ex) { + caught = true; + } + if (caught) { + System.out.println("Array store check test passed"); + } else { + throw new TestFailure("Array store check test failed"); + } + } + + public static void main(String args[]) { + doit(new B[1], new A()); + } + +}

--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/jit/Arrays/ArrayTests/ArrayTests.java Fri Jun 01 15:48:55 2018 -0700 @@ -0,0 +1,184 @@ +/* + * Copyright (c) 2008, 2018, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +// srm 961012 +// Test if array stores and reads are correct for +// integral types and floating points + + +/* + * @test + * + * @summary converted from VM Testbase jit/Arrays/ArrayTests. + * VM Testbase keywords: [jit, quick] + * + * @library /vmTestbase + * /test/lib + * @run driver jdk.test.lib.FileInstaller . . + * @run main/othervm jit.Arrays.ArrayTests.ArrayTests + */ + +package jit.Arrays.ArrayTests; + +import nsk.share.TestFailure; + +public class ArrayTests { + int base_array[]; + static int the_int_res = 200; + static int the_char_res = 13041864; + static int the_byte_res = -312; + static int n = 400; + + ArrayTests() { + base_array = new int [n]; + int start_value = n/2; + for (int i=0; i<n; i++) { + base_array[i]= start_value; + start_value--; + } + }; + + void print() { + for (int i=0; i<base_array.length; i++) + System.out.print(" "+base_array[i]); + // System.out.println("Result is " + the_res); + } + + boolean with_chars () { + char char_array[] = new char[n]; + int res = 0; + for (int i=0; i<n; i++) { + char_array[i] = (char)base_array[i]; + // System.out.print (" " + (int) char_array[i]); + } + for (int i=0; i<n; i++) { + res += (int) char_array[i]; + } + System.out.println("chars " + res + " == " + the_char_res); + return (res==the_char_res); + } + + boolean with_bytes () { + byte byte_array[] = new byte[n]; + int res = 0; + for (int i=0; i<n; i++) { + byte_array[i] = (byte)base_array[i]; + } + for (int i=0; i<n; i++) { + res += (int) byte_array[i]; + } + System.out.println("bytes " + res + " == " + the_byte_res); + return res==the_byte_res; + } + + boolean with_shorts () { + short short_array[] = new short[n]; + int res = 0; + for (int i=0; i<n; i++) { + short_array[i] = (short)base_array[i]; + } + for (int i=0; i<n; i++) { + res += (int) short_array[i]; + } + System.out.println("shorts " + res + " == " + the_int_res); + return res==the_int_res; + } + + boolean with_ints () { + int res = 0; + for (int i=0; i<n; i++) { + res += base_array[i]; + } + // base_array is integer + return (res==the_int_res); + } + + boolean with_longs() { + long long_array[] = new long[n]; + int res = 0; + for (int i=0; i<n; i++) { + long_array[i] = (long)base_array[i]; + } + for (int i=0; i<n; i++) { + res += (int) long_array[i]; + } + System.out.println("longs " + res + " == " + the_int_res); + return res==the_int_res; + } + + boolean with_floats () { + float float_array[] = new float[n]; + int res = 0; + for (int i=0; i<n; i++) { + float_array[i] = (float)base_array[i]; + } + for (int i=0; i<n; i++) { + res += (int) float_array[i]; + } + System.out.println("floats " + res + " == " + the_int_res); + return res==the_int_res; + } + + boolean with_doubles () { + double double_array[] = new double[n]; + int res = 0; + for (int i=0; i<n; i++) { + double_array[i] = (double)base_array[i]; + } + for (int i=0; i<n; i++) { + res += (int) double_array[i]; + } + System.out.println("doubles " + res + " == " + the_int_res); + return res==the_int_res; + } + + void check(String msg, boolean flag) { + if (!flag) { + System.out.println("ERROR in " + msg); + } + } + + boolean execute() { + // print(); + boolean res = true; + res = res & with_chars(); check("chars",res); + res = res & with_shorts(); check("shorts",res); + res = res & with_bytes(); check("bytes",res); + res = res & with_ints(); check("ints",res); + res = res & with_longs(); check("longs",res); + res = res & with_floats(); check("floats",res); + res = res & with_doubles(); check("doubles",res); + + return res; + } + + + public static void main (String s[]) { + boolean res = true; + ArrayTests at = new ArrayTests(); + res = res & at.execute(); + + if (res) System.out.println("Array read/write testsOK (srm 10/22/96)"); + else throw new TestFailure("Error in read/write array tests!"); + } + +}

--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/jit/CEETest/CEETest.java Fri Jun 01 15:48:55 2018 -0700 @@ -0,0 +1,326 @@ +/* + * Copyright (c) 2008, 2018, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + * @test + * + * @summary converted from VM Testbase jit/CEETest. + * VM Testbase keywords: [jit, quick] + * + * @library /vmTestbase + * /test/lib + * @run driver jdk.test.lib.FileInstaller . . + * @run main/othervm jit.CEETest.CEETest + */ + +package jit.CEETest; + +import java.io.PrintStream; +import nsk.share.TestFailure; + +public class CEETest { + + public static final long WarmUp = 1500; + public static final long Iterations = 100000; + + public static void main(String args[]) { + boolean pass = true; + for (int i=0; ( i < WarmUp ) & pass; i++) { + pass = pass & doInt(); + pass = pass & doBoolean(); + pass = pass & doByte(); + pass = pass & doChar(); + pass = pass & doShort(); + pass = pass & doLong(); + pass = pass & doFloat(); + pass = pass & doDouble(); + pass = pass & doObject(); + pass = pass & doBitOps(); + } + + long start = System.currentTimeMillis() ; + for (int i=0; i<Iterations & pass; i++) { + pass = pass & doInt(); + pass = pass & doBoolean(); + pass = pass & doByte(); + pass = pass & doChar(); + pass = pass & doShort(); + pass = pass & doLong(); + pass = pass & doFloat(); + pass = pass & doDouble(); + pass = pass & doObject(); + pass = pass & doBitOps(); + } + + long duration = System.currentTimeMillis() - start; + + if (true == pass) { + System.out.println ("CEETest PASSed in " + duration + " ms."); + } + else { + throw new TestFailure("CEETest FAILed in " + duration + " ms."); + } + } + + public static boolean doInt () { + + int x = 0; + int y = 1; + + int a = (x == y) ? x : y; + int b = (x != y) ? y : x; + int c = (x < y) ? y : x; + int d = (x > y) ? x : y; + int e = (x <= y) ? y : x; + int f = (x >= y) ? x : y; + + if ( (a != y) || + (b != y) || + (c != y) || + (d != y) || + (e != y) || + (f != y) ) { + System.err.println ("doInt() failed"); + return false; + } + else { + return true; + } + } + + public static boolean doBoolean () { + + boolean x = false; + boolean y = !x; + boolean a = (x == y) ? x : y; + boolean b = (x != y) ? y : x; + + if ( (a == y) && + (b == y) ) { + return true; + } + else { + System.err.println ("doBoolean() failed"); + return false; + } + } + + public static boolean doByte () { + + byte x = 0; + byte y = 1; + + byte a = (x == y) ? x : y; + byte b = (x != y) ? y : x; + byte c = (x < y) ? y : x; + byte d = (x > y) ? x : y; + byte e = (x <= y) ? y : x; + byte f = (x >= y) ? x : y; + + if ( (a != y) || + (b != y) || + (c != y) || + (d != y) || + (e != y) || + (f != y) ) { + System.err.println ("doByte() failed"); + return false; + } + else { + return true; + } + } + + public static boolean doChar () { + + char x = 0; + char y = 1; + + char a = (x == y) ? x : y; + char b = (x != y) ? y : x; + char c = (x < y) ? y : x; + char d = (x > y) ? x : y; + char e = (x <= y) ? y : x; + char f = (x >= y) ? x : y; + + if ( (a == y) && + (b == y) && + (c == y) && + (d == y) && + (e == y) && + (f == y) ) { + return true; + } + else { + System.err.println ("doChar() failed"); + return false; + } + } + + public static boolean doShort () { + + short x = 0; + short y = 1; + + short a = (x == y) ? x : y; + short b = (x != y) ? y : x; + short c = (x < y) ? y : x; + short d = (x > y) ? x : y; + short e = (x <= y) ? y : x; + short f = (x >= y) ? x : y; + + if ( (a != y) || + (b != y) || + (c != y) || + (d != y) || + (e != y) || + (f != y) ) { + System.err.println ("doShort() failed"); + return false; + } + else { + return true; + } + } + + public static boolean doLong () { + + long x = 0; + long y = 1; + long a = (x == y) ? x : y; + long b = (x != y) ? y : x; + long c = (x < y) ? y : x; + long d = (x > y) ? x : y; + long e = (x <= y) ? y : x; + long f = (x >= y) ? x : y; + + if ( (a == y) && + (b == y) && + (c == y) && + (d == y) && + (e == y) && + (f == y) ) { + return true; + } + else { + System.err.println ("doLong() failed"); + return false; + } + } + + public static boolean doFloat () { + + float x = 0.0f; + float y = 1.0f; + float a = (x == y) ? x : y; + float b = (x != y) ? y : x; + float c = (x < y) ? y : x; + float d = (x > y) ? x : y; + float e = (x <= y) ? y : x; + float f = (x >= y) ? x : y; + + if ( (a != y) || + (b != y) || + (c != y) || + (d != y) || + (e != y) || + (f != y) ) { + System.err.println ("doFloat() failed"); + return false; + } + else { + return true; + } + } + + public static boolean doDouble () { + + double x = 0.0; + double y = 1.0; + double a = (x == y) ? x : y; + double b = (x != y) ? y : x; + double c = (x < y) ? y : x; + double d = (x <= y) ? y : x; + double e = (x > y) ? x : y; + double f = (x >= y) ? x : y; + + if ( (a == y) && + (b == y) && + (c == y) && + (d == y) && + (e == y) && + (f == y) ) { + return true; + } + else { + System.err.println ("doDouble() failed"); + return false; + } + } + + public static boolean doObject () { + + String x = new String("x"); + String y = new String("y"); + String a = (x == y) ? x : y; + String b = (x != y) ? y : x; + String c = (x instanceof String) ? y : x; + + if ( (a != y) || + (b != y) || + (c != y) ) { + System.err.println ("doBoolean() failed"); + return false; + } + else { + return true; + } + } + + public static boolean doBitOps () { + int x = 0; + int y = 1; + + int a = x; a += y; + int b = (x == y) ? x : (x | y); + int c = (x == y) ? x : (x ^ y); + int d = (x == y) ? x : (y & y); + int e = (x == y) ? x : (y % 2); + int f = (x == y) ? x : (2 >> y); + int g = (x == y) ? x : (~-2); + + if ( (a == y) && + (b == y) && + (c == y) && + (d == y) && + (e == y) && + (f == y) && + (g == y) ) { + return true; + } else { + System.err.println ("doBoolean() failed"); + return false; + } + } + +}

--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/jit/CondExpr/CondExpr.java Fri Jun 01 15:48:55 2018 -0700 @@ -0,0 +1,93 @@ +/* + * Copyright (c) 2008, 2018, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +// test the conditional expressions + + +/* + * @test + * + * @summary converted from VM Testbase jit/CondExpr. + * VM Testbase keywords: [jit, quick] + * + * @library /vmTestbase + * /test/lib + * @run driver jdk.test.lib.FileInstaller . . + * @run main/othervm jit.CondExpr.CondExpr + */ + +package jit.CondExpr; + +import nsk.share.TestFailure; + +public class CondExpr { + + public static void trace (String s, int res) { + System.out.println("test result for " + s + " is " + res); + } + + public static int test_int1(int arg) { return (arg==10) ? 1 : 2; } + + public static int test_int(int arg) { return test_int1(arg) + test_int1(arg+1); } + + public static long test_long1(long arg) { return (arg==10) ? 1l : 2l; } + + public static int test_long(long arg) { return (int)(test_long1(arg) + test_long1(arg+1)); } + + public static float test_float1(float arg) { return (arg==10.0f) ? 1.0f : 2.0f; } + + public static int test_float(float arg) { return (int)(test_float1(arg) + test_float1(arg+1)); } + + public static double test_double1(double arg) { return (arg==10.0) ? 1.0 : 2.0; } + + public static int test_double(double arg) { return (int)(test_double1(arg) + test_double1(arg+1)); } + + + public static int nested_test_int1(int arg) { + return (arg>1) ? ((arg==10) ? 1 : 2) : ((arg==-10) ? 3: 4); + } + + + + public static int nested_test_int (int arg) { + return (nested_test_int1 (arg) + nested_test_int1 (arg+1) + nested_test_int1 (-arg) + nested_test_int1 (-arg-1)); } + + public static void main(String s[]) { + System.out.println ("Testing conditional expressions (srm 10/22)"); + boolean correct = true; + int res = 0; + res = test_int(10); trace("test_int", res); + correct = correct & ( res == 3); + res = test_long(10l); trace("test_long", res); + correct = correct & ( res == 3); + res = test_float(10.0f); trace("test_float", res); + correct = correct & ( res == 3); + res = test_double(10.0); trace("test_double", res); + correct = correct & ( res == 3); + + res = nested_test_int(10); trace("nested_test_int", res); + correct = correct & ( res == 10); + + if (correct) System.out.println("Correct!"); + else throw new TestFailure("ERRROR in conditional expressions"); + } +}

--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/jit/DivTest/DivTest.java Fri Jun 01 15:48:55 2018 -0700 @@ -0,0 +1,65 @@ +/* + * Copyright (c) 2008, 2018, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +// DivTest.java +// bug-12 + + +/* + * @test + * + * @summary converted from VM Testbase jit/DivTest. + * VM Testbase keywords: [jit, quick] + * + * @library /vmTestbase + * /test/lib + * @run driver jdk.test.lib.FileInstaller . . + * @build jit.DivTest.DivTest + * @run driver ExecDriver --java jit.DivTest.DivTest + */ + +package jit.DivTest; + +import nsk.share.TestFailure; + +class DivTest{ + static int n; + static boolean test1 (int n1, int n2) { + try { + n = n1 / n2; + System.out.println(n); + return true; + } catch (Exception e) { + System.out.println(e); + return false; + } + } + public static void main(String s[]) { + boolean failed; + failed = test1 (-1, 0); + failed |= !test1 (-1, 0x80000000); + failed |= !test1 (0, -1); + failed |= !test1 (0x80000000, -1); + if (failed) + throw new TestFailure("Test failed"); + } +}

--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/jit/ExcOpt/ExcOpt.java Fri Jun 01 15:48:55 2018 -0700 @@ -0,0 +1,70 @@ +/* + * Copyright (c) 2008, 2018, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +// tests exception handler inside optimizable loops and around them + + +/* + * @test + * + * @summary converted from VM Testbase jit/ExcOpt. + * VM Testbase keywords: [jit, quick] + * + * @library /vmTestbase + * /test/lib + * @run driver jdk.test.lib.FileInstaller . . + * @run main/othervm jit.ExcOpt.ExcOpt + */ + +package jit.ExcOpt; + +import nsk.share.TestFailure; + +public class ExcOpt { + static int x; + + public static void main (String s[]) { + + x = 0; + + try { + for (int i = 1; i < 100; i++) { + x += 1; + } + } catch (Exception e) { + x = 0; + } + + for (int i=1; i < 100; i++) { + try { + x += 1; + } catch (Exception e) { + x = 0; + } + } + + System.out.println("Done " + x); + + if (x != 198) + throw new TestFailure("Test failed (x != 198)"); + } +}

--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/jit/FloatingPoint/FPCompare/TestFPBinop/TestFPBinop.gold Fri Jun 01 15:48:55 2018 -0700 @@ -0,0 +1,8712 @@ +1.4E-45 + 1.4E-45 = 2.8E-45, with float param operands +1.4E-45 - 1.4E-45 = 0.0, with float param operands +1.4E-45 * 1.4E-45 = 0.0, with float param operands +1.4E-45 / 1.4E-45 = 1.0, with float param operands +1.4E-45 + 1.4E-45 = 2.8E-45, with float local operands +1.4E-45 - 1.4E-45 = 0.0, with float local operands +1.4E-45 * 1.4E-45 = 0.0, with float local operands +1.4E-45 / 1.4E-45 = 1.0, with float local operands +1.4E-45 + 1.4E-45 = 2.8E-45, with float static operands +1.4E-45 - 1.4E-45 = 0.0, with float static operands +1.4E-45 * 1.4E-45 = 0.0, with float static operands +1.4E-45 / 1.4E-45 = 1.0, with float static operands +1.4E-45 + 1.4E-45 = 2.8E-45, with float field operands +1.4E-45 - 1.4E-45 = 0.0, with float field operands +1.4E-45 * 1.4E-45 = 0.0, with float field operands +1.4E-45 / 1.4E-45 = 1.0, with float field operands +1.4E-45 + 1.4E-45 = 2.8E-45, with float a[i] operands +1.4E-45 - 1.4E-45 = 0.0, with float a[i] operands +1.4E-45 * 1.4E-45 = 0.0, with float a[i] operands +1.4E-45 / 1.4E-45 = 1.0, with float a[i] operands +1.4E-45 + 1.4E-45 = 2.8E-45, with float f(x) operands +1.4E-45 - 1.4E-45 = 0.0, with float f(x) operands +1.4E-45 * 1.4E-45 = 0.0, with float f(x) operands +1.4E-45 / 1.4E-45 = 1.0, with float f(x) operands +1.4E-45 + 1.4E-45 = 2.8E-45, with float lExpr operands +1.4E-45 - 1.4E-45 = 0.0, with float lExpr operands +1.4E-45 * 1.4E-45 = 0.0, with float lExpr operands +1.4E-45 / 1.4E-45 = 1.0, with float lExpr operands +1.4E-45 + 1.4E-45 = 2.8E-45, with float rExpr operands +1.4E-45 - 1.4E-45 = 0.0, with float rExpr operands +1.4E-45 * 1.4E-45 = 0.0, with float rExpr operands +1.4E-45 / 1.4E-45 = 1.0, with float rExpr operands +1.4E-45 + 1.4E-45 = 2.8E-45, with float exprs operands +1.4E-45 - 1.4E-45 = 0.0, with float exprs operands +1.4E-45 * 1.4E-45 = 0.0, with float exprs operands +1.4E-45 / 1.4E-45 = 1.0, with float exprs operands +1.4E-45 + 3.4028235E38 = 3.4028235E38, with float param operands +1.4E-45 - 3.4028235E38 = -3.4028235E38, with float param operands +1.4E-45 * 3.4028235E38 = 4.7683713E-7, with float param operands +1.4E-45 / 3.4028235E38 = 0.0, with float param operands +1.4E-45 + 3.4028235E38 = 3.4028235E38, with float local operands +1.4E-45 - 3.4028235E38 = -3.4028235E38, with float local operands +1.4E-45 * 3.4028235E38 = 4.7683713E-7, with float local operands +1.4E-45 / 3.4028235E38 = 0.0, with float local operands +1.4E-45 + 3.4028235E38 = 3.4028235E38, with float static operands +1.4E-45 - 3.4028235E38 = -3.4028235E38, with float static operands +1.4E-45 * 3.4028235E38 = 4.7683713E-7, with float static operands +1.4E-45 / 3.4028235E38 = 0.0, with float static operands +1.4E-45 + 3.4028235E38 = 3.4028235E38, with float field operands +1.4E-45 - 3.4028235E38 = -3.4028235E38, with float field operands +1.4E-45 * 3.4028235E38 = 4.7683713E-7, with float field operands +1.4E-45 / 3.4028235E38 = 0.0, with float field operands +1.4E-45 + 3.4028235E38 = 3.4028235E38, with float a[i] operands +1.4E-45 - 3.4028235E38 = -3.4028235E38, with float a[i] operands +1.4E-45 * 3.4028235E38 = 4.7683713E-7, with float a[i] operands +1.4E-45 / 3.4028235E38 = 0.0, with float a[i] operands +1.4E-45 + 3.4028235E38 = 3.4028235E38, with float f(x) operands +1.4E-45 - 3.4028235E38 = -3.4028235E38, with float f(x) operands +1.4E-45 * 3.4028235E38 = 4.7683713E-7, with float f(x) operands +1.4E-45 / 3.4028235E38 = 0.0, with float f(x) operands +1.4E-45 + 3.4028235E38 = 3.4028235E38, with float lExpr operands +1.4E-45 - 3.4028235E38 = -3.4028235E38, with float lExpr operands +1.4E-45 * 3.4028235E38 = 4.7683713E-7, with float lExpr operands +1.4E-45 / 3.4028235E38 = 0.0, with float lExpr operands +1.4E-45 + 3.4028235E38 = 3.4028235E38, with float rExpr operands +1.4E-45 - 3.4028235E38 = -3.4028235E38, with float rExpr operands +1.4E-45 * 3.4028235E38 = 4.7683713E-7, with float rExpr operands +1.4E-45 / 3.4028235E38 = 0.0, with float rExpr operands +1.4E-45 + 3.4028235E38 = 3.4028235E38, with float exprs operands +1.4E-45 - 3.4028235E38 = -3.4028235E38, with float exprs operands +1.4E-45 * 3.4028235E38 = 4.7683713E-7, with float exprs operands +1.4E-45 / 3.4028235E38 = 0.0, with float exprs operands +1.4E-45 + -1.4E-45 = 0.0, with float param operands +1.4E-45 - -1.4E-45 = 2.8E-45, with float param operands +1.4E-45 * -1.4E-45 = -0.0, with float param operands +1.4E-45 / -1.4E-45 = -1.0, with float param operands +1.4E-45 + -1.4E-45 = 0.0, with float local operands +1.4E-45 - -1.4E-45 = 2.8E-45, with float local operands +1.4E-45 * -1.4E-45 = -0.0, with float local operands +1.4E-45 / -1.4E-45 = -1.0, with float local operands +1.4E-45 + -1.4E-45 = 0.0, with float static operands +1.4E-45 - -1.4E-45 = 2.8E-45, with float static operands +1.4E-45 * -1.4E-45 = -0.0, with float static operands +1.4E-45 / -1.4E-45 = -1.0, with float static operands +1.4E-45 + -1.4E-45 = 0.0, with float field operands +1.4E-45 - -1.4E-45 = 2.8E-45, with float field operands +1.4E-45 * -1.4E-45 = -0.0, with float field operands +1.4E-45 / -1.4E-45 = -1.0, with float field operands +1.4E-45 + -1.4E-45 = 0.0, with float a[i] operands +1.4E-45 - -1.4E-45 = 2.8E-45, with float a[i] operands +1.4E-45 * -1.4E-45 = -0.0, with float a[i] operands +1.4E-45 / -1.4E-45 = -1.0, with float a[i] operands +1.4E-45 + -1.4E-45 = 0.0, with float f(x) operands +1.4E-45 - -1.4E-45 = 2.8E-45, with float f(x) operands +1.4E-45 * -1.4E-45 = -0.0, with float f(x) operands +1.4E-45 / -1.4E-45 = -1.0, with float f(x) operands +1.4E-45 + -1.4E-45 = 0.0, with float lExpr operands +1.4E-45 - -1.4E-45 = 2.8E-45, with float lExpr operands +1.4E-45 * -1.4E-45 = -0.0, with float lExpr operands +1.4E-45 / -1.4E-45 = -1.0, with float lExpr operands +1.4E-45 + -1.4E-45 = 0.0, with float rExpr operands +1.4E-45 - -1.4E-45 = 2.8E-45, with float rExpr operands +1.4E-45 * -1.4E-45 = -0.0, with float rExpr operands +1.4E-45 / -1.4E-45 = -1.0, with float rExpr operands +1.4E-45 + -1.4E-45 = 0.0, with float exprs operands +1.4E-45 - -1.4E-45 = 2.8E-45, with float exprs operands +1.4E-45 * -1.4E-45 = -0.0, with float exprs operands +1.4E-45 / -1.4E-45 = -1.0, with float exprs operands +1.4E-45 + -3.4028235E38 = -3.4028235E38, with float param operands +1.4E-45 - -3.4028235E38 = 3.4028235E38, with float param operands +1.4E-45 * -3.4028235E38 = -4.7683713E-7, with float param operands +1.4E-45 / -3.4028235E38 = -0.0, with float param operands +1.4E-45 + -3.4028235E38 = -3.4028235E38, with float local operands +1.4E-45 - -3.4028235E38 = 3.4028235E38, with float local operands +1.4E-45 * -3.4028235E38 = -4.7683713E-7, with float local operands +1.4E-45 / -3.4028235E38 = -0.0, with float local operands +1.4E-45 + -3.4028235E38 = -3.4028235E38, with float static operands +1.4E-45 - -3.4028235E38 = 3.4028235E38, with float static operands +1.4E-45 * -3.4028235E38 = -4.7683713E-7, with float static operands +1.4E-45 / -3.4028235E38 = -0.0, with float static operands +1.4E-45 + -3.4028235E38 = -3.4028235E38, with float field operands +1.4E-45 - -3.4028235E38 = 3.4028235E38, with float field operands +1.4E-45 * -3.4028235E38 = -4.7683713E-7, with float field operands +1.4E-45 / -3.4028235E38 = -0.0, with float field operands +1.4E-45 + -3.4028235E38 = -3.4028235E38, with float a[i] operands +1.4E-45 - -3.4028235E38 = 3.4028235E38, with float a[i] operands +1.4E-45 * -3.4028235E38 = -4.7683713E-7, with float a[i] operands +1.4E-45 / -3.4028235E38 = -0.0, with float a[i] operands +1.4E-45 + -3.4028235E38 = -3.4028235E38, with float f(x) operands +1.4E-45 - -3.4028235E38 = 3.4028235E38, with float f(x) operands +1.4E-45 * -3.4028235E38 = -4.7683713E-7, with float f(x) operands +1.4E-45 / -3.4028235E38 = -0.0, with float f(x) operands +1.4E-45 + -3.4028235E38 = -3.4028235E38, with float lExpr operands +1.4E-45 - -3.4028235E38 = 3.4028235E38, with float lExpr operands +1.4E-45 * -3.4028235E38 = -4.7683713E-7, with float lExpr operands +1.4E-45 / -3.4028235E38 = -0.0, with float lExpr operands +1.4E-45 + -3.4028235E38 = -3.4028235E38, with float rExpr operands +1.4E-45 - -3.4028235E38 = 3.4028235E38, with float rExpr operands +1.4E-45 * -3.4028235E38 = -4.7683713E-7, with float rExpr operands +1.4E-45 / -3.4028235E38 = -0.0, with float rExpr operands +1.4E-45 + -3.4028235E38 = -3.4028235E38, with float exprs operands +1.4E-45 - -3.4028235E38 = 3.4028235E38, with float exprs operands +1.4E-45 * -3.4028235E38 = -4.7683713E-7, with float exprs operands +1.4E-45 / -3.4028235E38 = -0.0, with float exprs operands +1.4E-45 + -1.0 = -1.0, with float param operands +1.4E-45 - -1.0 = 1.0, with float param operands +1.4E-45 * -1.0 = -1.4E-45, with float param operands +1.4E-45 / -1.0 = -1.4E-45, with float param operands +1.4E-45 + -1.0 = -1.0, with float local operands +1.4E-45 - -1.0 = 1.0, with float local operands +1.4E-45 * -1.0 = -1.4E-45, with float local operands +1.4E-45 / -1.0 = -1.4E-45, with float local operands +1.4E-45 + -1.0 = -1.0, with float static operands +1.4E-45 - -1.0 = 1.0, with float static operands +1.4E-45 * -1.0 = -1.4E-45, with float static operands +1.4E-45 / -1.0 = -1.4E-45, with float static operands +1.4E-45 + -1.0 = -1.0, with float field operands +1.4E-45 - -1.0 = 1.0, with float field operands +1.4E-45 * -1.0 = -1.4E-45, with float field operands +1.4E-45 / -1.0 = -1.4E-45, with float field operands +1.4E-45 + -1.0 = -1.0, with float a[i] operands +1.4E-45 - -1.0 = 1.0, with float a[i] operands +1.4E-45 * -1.0 = -1.4E-45, with float a[i] operands +1.4E-45 / -1.0 = -1.4E-45, with float a[i] operands +1.4E-45 + -1.0 = -1.0, with float f(x) operands +1.4E-45 - -1.0 = 1.0, with float f(x) operands +1.4E-45 * -1.0 = -1.4E-45, with float f(x) operands +1.4E-45 / -1.0 = -1.4E-45, with float f(x) operands +1.4E-45 + -1.0 = -1.0, with float lExpr operands +1.4E-45 - -1.0 = 1.0, with float lExpr operands +1.4E-45 * -1.0 = -1.4E-45, with float lExpr operands +1.4E-45 / -1.0 = -1.4E-45, with float lExpr operands +1.4E-45 + -1.0 = -1.0, with float rExpr operands +1.4E-45 - -1.0 = 1.0, with float rExpr operands +1.4E-45 * -1.0 = -1.4E-45, with float rExpr operands +1.4E-45 / -1.0 = -1.4E-45, with float rExpr operands +1.4E-45 + -1.0 = -1.0, with float exprs operands +1.4E-45 - -1.0 = 1.0, with float exprs operands +1.4E-45 * -1.0 = -1.4E-45, with float exprs operands +1.4E-45 / -1.0 = -1.4E-45, with float exprs operands +1.4E-45 + 1.0 = 1.0, with float param operands +1.4E-45 - 1.0 = -1.0, with float param operands +1.4E-45 * 1.0 = 1.4E-45, with float param operands +1.4E-45 / 1.0 = 1.4E-45, with float param operands +1.4E-45 + 1.0 = 1.0, with float local operands +1.4E-45 - 1.0 = -1.0, with float local operands +1.4E-45 * 1.0 = 1.4E-45, with float local operands +1.4E-45 / 1.0 = 1.4E-45, with float local operands +1.4E-45 + 1.0 = 1.0, with float static operands +1.4E-45 - 1.0 = -1.0, with float static operands +1.4E-45 * 1.0 = 1.4E-45, with float static operands +1.4E-45 / 1.0 = 1.4E-45, with float static operands +1.4E-45 + 1.0 = 1.0, with float field operands +1.4E-45 - 1.0 = -1.0, with float field operands +1.4E-45 * 1.0 = 1.4E-45, with float field operands +1.4E-45 / 1.0 = 1.4E-45, with float field operands +1.4E-45 + 1.0 = 1.0, with float a[i] operands +1.4E-45 - 1.0 = -1.0, with float a[i] operands +1.4E-45 * 1.0 = 1.4E-45, with float a[i] operands +1.4E-45 / 1.0 = 1.4E-45, with float a[i] operands +1.4E-45 + 1.0 = 1.0, with float f(x) operands +1.4E-45 - 1.0 = -1.0, with float f(x) operands +1.4E-45 * 1.0 = 1.4E-45, with float f(x) operands +1.4E-45 / 1.0 = 1.4E-45, with float f(x) operands +1.4E-45 + 1.0 = 1.0, with float lExpr operands +1.4E-45 - 1.0 = -1.0, with float lExpr operands +1.4E-45 * 1.0 = 1.4E-45, with float lExpr operands +1.4E-45 / 1.0 = 1.4E-45, with float lExpr operands +1.4E-45 + 1.0 = 1.0, with float rExpr operands +1.4E-45 - 1.0 = -1.0, with float rExpr operands +1.4E-45 * 1.0 = 1.4E-45, with float rExpr operands +1.4E-45 / 1.0 = 1.4E-45, with float rExpr operands +1.4E-45 + 1.0 = 1.0, with float exprs operands +1.4E-45 - 1.0 = -1.0, with float exprs operands +1.4E-45 * 1.0 = 1.4E-45, with float exprs operands +1.4E-45 / 1.0 = 1.4E-45, with float exprs operands +1.4E-45 + -0.0 = 1.4E-45, with float param operands +1.4E-45 - -0.0 = 1.4E-45, with float param operands +1.4E-45 * -0.0 = -0.0, with float param operands +1.4E-45 / -0.0 = -Infinity, with float param operands +1.4E-45 + -0.0 = 1.4E-45, with float local operands +1.4E-45 - -0.0 = 1.4E-45, with float local operands +1.4E-45 * -0.0 = -0.0, with float local operands +1.4E-45 / -0.0 = -Infinity, with float local operands +1.4E-45 + -0.0 = 1.4E-45, with float static operands +1.4E-45 - -0.0 = 1.4E-45, with float static operands +1.4E-45 * -0.0 = -0.0, with float static operands +1.4E-45 / -0.0 = -Infinity, with float static operands +1.4E-45 + -0.0 = 1.4E-45, with float field operands +1.4E-45 - -0.0 = 1.4E-45, with float field operands +1.4E-45 * -0.0 = -0.0, with float field operands +1.4E-45 / -0.0 = -Infinity, with float field operands +1.4E-45 + -0.0 = 1.4E-45, with float a[i] operands +1.4E-45 - -0.0 = 1.4E-45, with float a[i] operands +1.4E-45 * -0.0 = -0.0, with float a[i] operands +1.4E-45 / -0.0 = -Infinity, with float a[i] operands +1.4E-45 + -0.0 = 1.4E-45, with float f(x) operands +1.4E-45 - -0.0 = 1.4E-45, with float f(x) operands +1.4E-45 * -0.0 = -0.0, with float f(x) operands +1.4E-45 / -0.0 = -Infinity, with float f(x) operands +1.4E-45 + -0.0 = 1.4E-45, with float lExpr operands +1.4E-45 - -0.0 = 1.4E-45, with float lExpr operands +1.4E-45 * -0.0 = -0.0, with float lExpr operands +1.4E-45 / -0.0 = -Infinity, with float lExpr operands +1.4E-45 + 0.0 = 1.4E-45, with float rExpr operands +1.4E-45 - 0.0 = 1.4E-45, with float rExpr operands +1.4E-45 * 0.0 = 0.0, with float rExpr operands +1.4E-45 / 0.0 = Infinity, with float rExpr operands +1.4E-45 + 0.0 = 1.4E-45, with float exprs operands +1.4E-45 - 0.0 = 1.4E-45, with float exprs operands +1.4E-45 * 0.0 = 0.0, with float exprs operands +1.4E-45 / 0.0 = Infinity, with float exprs operands +1.4E-45 + 0.0 = 1.4E-45, with float param operands +1.4E-45 - 0.0 = 1.4E-45, with float param operands +1.4E-45 * 0.0 = 0.0, with float param operands +1.4E-45 / 0.0 = Infinity, with float param operands +1.4E-45 + 0.0 = 1.4E-45, with float local operands +1.4E-45 - 0.0 = 1.4E-45, with float local operands +1.4E-45 * 0.0 = 0.0, with float local operands +1.4E-45 / 0.0 = Infinity, with float local operands +1.4E-45 + 0.0 = 1.4E-45, with float static operands +1.4E-45 - 0.0 = 1.4E-45, with float static operands +1.4E-45 * 0.0 = 0.0, with float static operands +1.4E-45 / 0.0 = Infinity, with float static operands +1.4E-45 + 0.0 = 1.4E-45, with float field operands +1.4E-45 - 0.0 = 1.4E-45, with float field operands +1.4E-45 * 0.0 = 0.0, with float field operands +1.4E-45 / 0.0 = Infinity, with float field operands +1.4E-45 + 0.0 = 1.4E-45, with float a[i] operands +1.4E-45 - 0.0 = 1.4E-45, with float a[i] operands +1.4E-45 * 0.0 = 0.0, with float a[i] operands +1.4E-45 / 0.0 = Infinity, with float a[i] operands +1.4E-45 + 0.0 = 1.4E-45, with float f(x) operands +1.4E-45 - 0.0 = 1.4E-45, with float f(x) operands +1.4E-45 * 0.0 = 0.0, with float f(x) operands +1.4E-45 / 0.0 = Infinity, with float f(x) operands +1.4E-45 + 0.0 = 1.4E-45, with float lExpr operands +1.4E-45 - 0.0 = 1.4E-45, with float lExpr operands +1.4E-45 * 0.0 = 0.0, with float lExpr operands +1.4E-45 / 0.0 = Infinity, with float lExpr operands +1.4E-45 + 0.0 = 1.4E-45, with float rExpr operands +1.4E-45 - 0.0 = 1.4E-45, with float rExpr operands +1.4E-45 * 0.0 = 0.0, with float rExpr operands +1.4E-45 / 0.0 = Infinity, with float rExpr operands +1.4E-45 + 0.0 = 1.4E-45, with float exprs operands +1.4E-45 - 0.0 = 1.4E-45, with float exprs operands +1.4E-45 * 0.0 = 0.0, with float exprs operands +1.4E-45 / 0.0 = Infinity, with float exprs operands +1.4E-45 + -Infinity = -Infinity, with float param operands +1.4E-45 - -Infinity = Infinity, with float param operands +1.4E-45 * -Infinity = -Infinity, with float param operands +1.4E-45 / -Infinity = -0.0, with float param operands +1.4E-45 + -Infinity = -Infinity, with float local operands +1.4E-45 - -Infinity = Infinity, with float local operands +1.4E-45 * -Infinity = -Infinity, with float local operands +1.4E-45 / -Infinity = -0.0, with float local operands +1.4E-45 + -Infinity = -Infinity, with float static operands +1.4E-45 - -Infinity = Infinity, with float static operands +1.4E-45 * -Infinity = -Infinity, with float static operands +1.4E-45 / -Infinity = -0.0, with float static operands +1.4E-45 + -Infinity = -Infinity, with float field operands +1.4E-45 - -Infinity = Infinity, with float field operands +1.4E-45 * -Infinity = -Infinity, with float field operands +1.4E-45 / -Infinity = -0.0, with float field operands +1.4E-45 + -Infinity = -Infinity, with float a[i] operands +1.4E-45 - -Infinity = Infinity, with float a[i] operands +1.4E-45 * -Infinity = -Infinity, with float a[i] operands +1.4E-45 / -Infinity = -0.0, with float a[i] operands +1.4E-45 + -Infinity = -Infinity, with float f(x) operands +1.4E-45 - -Infinity = Infinity, with float f(x) operands +1.4E-45 * -Infinity = -Infinity, with float f(x) operands +1.4E-45 / -Infinity = -0.0, with float f(x) operands +1.4E-45 + -Infinity = -Infinity, with float lExpr operands +1.4E-45 - -Infinity = Infinity, with float lExpr operands +1.4E-45 * -Infinity = -Infinity, with float lExpr operands +1.4E-45 / -Infinity = -0.0, with float lExpr operands +1.4E-45 + -Infinity = -Infinity, with float rExpr operands +1.4E-45 - -Infinity = Infinity, with float rExpr operands +1.4E-45 * -Infinity = -Infinity, with float rExpr operands +1.4E-45 / -Infinity = -0.0, with float rExpr operands +1.4E-45 + -Infinity = -Infinity, with float exprs operands +1.4E-45 - -Infinity = Infinity, with float exprs operands +1.4E-45 * -Infinity = -Infinity, with float exprs operands +1.4E-45 / -Infinity = -0.0, with float exprs operands +1.4E-45 + Infinity = Infinity, with float param operands +1.4E-45 - Infinity = -Infinity, with float param operands +1.4E-45 * Infinity = Infinity, with float param operands +1.4E-45 / Infinity = 0.0, with float param operands +1.4E-45 + Infinity = Infinity, with float local operands +1.4E-45 - Infinity = -Infinity, with float local operands +1.4E-45 * Infinity = Infinity, with float local operands +1.4E-45 / Infinity = 0.0, with float local operands +1.4E-45 + Infinity = Infinity, with float static operands +1.4E-45 - Infinity = -Infinity, with float static operands +1.4E-45 * Infinity = Infinity, with float static operands +1.4E-45 / Infinity = 0.0, with float static operands +1.4E-45 + Infinity = Infinity, with float field operands +1.4E-45 - Infinity = -Infinity, with float field operands +1.4E-45 * Infinity = Infinity, with float field operands +1.4E-45 / Infinity = 0.0, with float field operands +1.4E-45 + Infinity = Infinity, with float a[i] operands +1.4E-45 - Infinity = -Infinity, with float a[i] operands +1.4E-45 * Infinity = Infinity, with float a[i] operands +1.4E-45 / Infinity = 0.0, with float a[i] operands +1.4E-45 + Infinity = Infinity, with float f(x) operands +1.4E-45 - Infinity = -Infinity, with float f(x) operands +1.4E-45 * Infinity = Infinity, with float f(x) operands +1.4E-45 / Infinity = 0.0, with float f(x) operands +1.4E-45 + Infinity = Infinity, with float lExpr operands +1.4E-45 - Infinity = -Infinity, with float lExpr operands +1.4E-45 * Infinity = Infinity, with float lExpr operands +1.4E-45 / Infinity = 0.0, with float lExpr operands +1.4E-45 + Infinity = Infinity, with float rExpr operands +1.4E-45 - Infinity = -Infinity, with float rExpr operands +1.4E-45 * Infinity = Infinity, with float rExpr operands +1.4E-45 / Infinity = 0.0, with float rExpr operands +1.4E-45 + Infinity = Infinity, with float exprs operands +1.4E-45 - Infinity = -Infinity, with float exprs operands +1.4E-45 * Infinity = Infinity, with float exprs operands +1.4E-45 / Infinity = 0.0, with float exprs operands +1.4E-45 + NaN = NaN, with float param operands +1.4E-45 - NaN = NaN, with float param operands +1.4E-45 * NaN = NaN, with float param operands +1.4E-45 / NaN = NaN, with float param operands +1.4E-45 + NaN = NaN, with float local operands +1.4E-45 - NaN = NaN, with float local operands +1.4E-45 * NaN = NaN, with float local operands +1.4E-45 / NaN = NaN, with float local operands +1.4E-45 + NaN = NaN, with float static operands +1.4E-45 - NaN = NaN, with float static operands +1.4E-45 * NaN = NaN, with float static operands +1.4E-45 / NaN = NaN, with float static operands +1.4E-45 + NaN = NaN, with float field operands +1.4E-45 - NaN = NaN, with float field operands +1.4E-45 * NaN = NaN, with float field operands +1.4E-45 / NaN = NaN, with float field operands +1.4E-45 + NaN = NaN, with float a[i] operands +1.4E-45 - NaN = NaN, with float a[i] operands +1.4E-45 * NaN = NaN, with float a[i] operands +1.4E-45 / NaN = NaN, with float a[i] operands +1.4E-45 + NaN = NaN, with float f(x) operands +1.4E-45 - NaN = NaN, with float f(x) operands +1.4E-45 * NaN = NaN, with float f(x) operands +1.4E-45 / NaN = NaN, with float f(x) operands +1.4E-45 + NaN = NaN, with float lExpr operands +1.4E-45 - NaN = NaN, with float lExpr operands +1.4E-45 * NaN = NaN, with float lExpr operands +1.4E-45 / NaN = NaN, with float lExpr operands +1.4E-45 + NaN = NaN, with float rExpr operands +1.4E-45 - NaN = NaN, with float rExpr operands +1.4E-45 * NaN = NaN, with float rExpr operands +1.4E-45 / NaN = NaN, with float rExpr operands +1.4E-45 + NaN = NaN, with float exprs operands +1.4E-45 - NaN = NaN, with float exprs operands +1.4E-45 * NaN = NaN, with float exprs operands +1.4E-45 / NaN = NaN, with float exprs operands +3.4028235E38 + 1.4E-45 = 3.4028235E38, with float param operands +3.4028235E38 - 1.4E-45 = 3.4028235E38, with float param operands +3.4028235E38 * 1.4E-45 = 4.7683713E-7, with float param operands +3.4028235E38 / 1.4E-45 = Infinity, with float param operands +3.4028235E38 + 1.4E-45 = 3.4028235E38, with float local operands +3.4028235E38 - 1.4E-45 = 3.4028235E38, with float local operands +3.4028235E38 * 1.4E-45 = 4.7683713E-7, with float local operands +3.4028235E38 / 1.4E-45 = Infinity, with float local operands +3.4028235E38 + 1.4E-45 = 3.4028235E38, with float static operands +3.4028235E38 - 1.4E-45 = 3.4028235E38, with float static operands +3.4028235E38 * 1.4E-45 = 4.7683713E-7, with float static operands +3.4028235E38 / 1.4E-45 = Infinity, with float static operands +3.4028235E38 + 1.4E-45 = 3.4028235E38, with float field operands +3.4028235E38 - 1.4E-45 = 3.4028235E38, with float field operands +3.4028235E38 * 1.4E-45 = 4.7683713E-7, with float field operands +3.4028235E38 / 1.4E-45 = Infinity, with float field operands +3.4028235E38 + 1.4E-45 = 3.4028235E38, with float a[i] operands +3.4028235E38 - 1.4E-45 = 3.4028235E38, with float a[i] operands +3.4028235E38 * 1.4E-45 = 4.7683713E-7, with float a[i] operands +3.4028235E38 / 1.4E-45 = Infinity, with float a[i] operands +3.4028235E38 + 1.4E-45 = 3.4028235E38, with float f(x) operands +3.4028235E38 - 1.4E-45 = 3.4028235E38, with float f(x) operands +3.4028235E38 * 1.4E-45 = 4.7683713E-7, with float f(x) operands +3.4028235E38 / 1.4E-45 = Infinity, with float f(x) operands +3.4028235E38 + 1.4E-45 = 3.4028235E38, with float lExpr operands +3.4028235E38 - 1.4E-45 = 3.4028235E38, with float lExpr operands +3.4028235E38 * 1.4E-45 = 4.7683713E-7, with float lExpr operands +3.4028235E38 / 1.4E-45 = Infinity, with float lExpr operands +3.4028235E38 + 1.4E-45 = 3.4028235E38, with float rExpr operands +3.4028235E38 - 1.4E-45 = 3.4028235E38, with float rExpr operands +3.4028235E38 * 1.4E-45 = 4.7683713E-7, with float rExpr operands +3.4028235E38 / 1.4E-45 = Infinity, with float rExpr operands +3.4028235E38 + 1.4E-45 = 3.4028235E38, with float exprs operands +3.4028235E38 - 1.4E-45 = 3.4028235E38, with float exprs operands +3.4028235E38 * 1.4E-45 = 4.7683713E-7, with float exprs operands +3.4028235E38 / 1.4E-45 = Infinity, with float exprs operands +3.4028235E38 + 3.4028235E38 = Infinity, with float param operands +3.4028235E38 - 3.4028235E38 = 0.0, with float param operands +3.4028235E38 * 3.4028235E38 = Infinity, with float param operands +3.4028235E38 / 3.4028235E38 = 1.0, with float param operands +3.4028235E38 + 3.4028235E38 = Infinity, with float local operands +3.4028235E38 - 3.4028235E38 = 0.0, with float local operands +3.4028235E38 * 3.4028235E38 = Infinity, with float local operands +3.4028235E38 / 3.4028235E38 = 1.0, with float local operands +3.4028235E38 + 3.4028235E38 = Infinity, with float static operands +3.4028235E38 - 3.4028235E38 = 0.0, with float static operands +3.4028235E38 * 3.4028235E38 = Infinity, with float static operands +3.4028235E38 / 3.4028235E38 = 1.0, with float static operands +3.4028235E38 + 3.4028235E38 = Infinity, with float field operands +3.4028235E38 - 3.4028235E38 = 0.0, with float field operands +3.4028235E38 * 3.4028235E38 = Infinity, with float field operands +3.4028235E38 / 3.4028235E38 = 1.0, with float field operands +3.4028235E38 + 3.4028235E38 = Infinity, with float a[i] operands +3.4028235E38 - 3.4028235E38 = 0.0, with float a[i] operands +3.4028235E38 * 3.4028235E38 = Infinity, with float a[i] operands +3.4028235E38 / 3.4028235E38 = 1.0, with float a[i] operands +3.4028235E38 + 3.4028235E38 = Infinity, with float f(x) operands +3.4028235E38 - 3.4028235E38 = 0.0, with float f(x) operands +3.4028235E38 * 3.4028235E38 = Infinity, with float f(x) operands +3.4028235E38 / 3.4028235E38 = 1.0, with float f(x) operands +3.4028235E38 + 3.4028235E38 = Infinity, with float lExpr operands +3.4028235E38 - 3.4028235E38 = 0.0, with float lExpr operands +3.4028235E38 * 3.4028235E38 = Infinity, with float lExpr operands +3.4028235E38 / 3.4028235E38 = 1.0, with float lExpr operands +3.4028235E38 + 3.4028235E38 = Infinity, with float rExpr operands +3.4028235E38 - 3.4028235E38 = 0.0, with float rExpr operands +3.4028235E38 * 3.4028235E38 = Infinity, with float rExpr operands +3.4028235E38 / 3.4028235E38 = 1.0, with float rExpr operands +3.4028235E38 + 3.4028235E38 = Infinity, with float exprs operands +3.4028235E38 - 3.4028235E38 = 0.0, with float exprs operands +3.4028235E38 * 3.4028235E38 = Infinity, with float exprs operands +3.4028235E38 / 3.4028235E38 = 1.0, with float exprs operands +3.4028235E38 + -1.4E-45 = 3.4028235E38, with float param operands +3.4028235E38 - -1.4E-45 = 3.4028235E38, with float param operands +3.4028235E38 * -1.4E-45 = -4.7683713E-7, with float param operands +3.4028235E38 / -1.4E-45 = -Infinity, with float param operands +3.4028235E38 + -1.4E-45 = 3.4028235E38, with float local operands +3.4028235E38 - -1.4E-45 = 3.4028235E38, with float local operands +3.4028235E38 * -1.4E-45 = -4.7683713E-7, with float local operands +3.4028235E38 / -1.4E-45 = -Infinity, with float local operands +3.4028235E38 + -1.4E-45 = 3.4028235E38, with float static operands +3.4028235E38 - -1.4E-45 = 3.4028235E38, with float static operands +3.4028235E38 * -1.4E-45 = -4.7683713E-7, with float static operands +3.4028235E38 / -1.4E-45 = -Infinity, with float static operands +3.4028235E38 + -1.4E-45 = 3.4028235E38, with float field operands +3.4028235E38 - -1.4E-45 = 3.4028235E38, with float field operands +3.4028235E38 * -1.4E-45 = -4.7683713E-7, with float field operands +3.4028235E38 / -1.4E-45 = -Infinity, with float field operands +3.4028235E38 + -1.4E-45 = 3.4028235E38, with float a[i] operands +3.4028235E38 - -1.4E-45 = 3.4028235E38, with float a[i] operands +3.4028235E38 * -1.4E-45 = -4.7683713E-7, with float a[i] operands +3.4028235E38 / -1.4E-45 = -Infinity, with float a[i] operands +3.4028235E38 + -1.4E-45 = 3.4028235E38, with float f(x) operands +3.4028235E38 - -1.4E-45 = 3.4028235E38, with float f(x) operands +3.4028235E38 * -1.4E-45 = -4.7683713E-7, with float f(x) operands +3.4028235E38 / -1.4E-45 = -Infinity, with float f(x) operands +3.4028235E38 + -1.4E-45 = 3.4028235E38, with float lExpr operands +3.4028235E38 - -1.4E-45 = 3.4028235E38, with float lExpr operands +3.4028235E38 * -1.4E-45 = -4.7683713E-7, with float lExpr operands +3.4028235E38 / -1.4E-45 = -Infinity, with float lExpr operands +3.4028235E38 + -1.4E-45 = 3.4028235E38, with float rExpr operands +3.4028235E38 - -1.4E-45 = 3.4028235E38, with float rExpr operands +3.4028235E38 * -1.4E-45 = -4.7683713E-7, with float rExpr operands +3.4028235E38 / -1.4E-45 = -Infinity, with float rExpr operands +3.4028235E38 + -1.4E-45 = 3.4028235E38, with float exprs operands +3.4028235E38 - -1.4E-45 = 3.4028235E38, with float exprs operands +3.4028235E38 * -1.4E-45 = -4.7683713E-7, with float exprs operands +3.4028235E38 / -1.4E-45 = -Infinity, with float exprs operands +3.4028235E38 + -3.4028235E38 = 0.0, with float param operands +3.4028235E38 - -3.4028235E38 = Infinity, with float param operands +3.4028235E38 * -3.4028235E38 = -Infinity, with float param operands +3.4028235E38 / -3.4028235E38 = -1.0, with float param operands +3.4028235E38 + -3.4028235E38 = 0.0, with float local operands +3.4028235E38 - -3.4028235E38 = Infinity, with float local operands +3.4028235E38 * -3.4028235E38 = -Infinity, with float local operands +3.4028235E38 / -3.4028235E38 = -1.0, with float local operands +3.4028235E38 + -3.4028235E38 = 0.0, with float static operands +3.4028235E38 - -3.4028235E38 = Infinity, with float static operands +3.4028235E38 * -3.4028235E38 = -Infinity, with float static operands +3.4028235E38 / -3.4028235E38 = -1.0, with float static operands +3.4028235E38 + -3.4028235E38 = 0.0, with float field operands +3.4028235E38 - -3.4028235E38 = Infinity, with float field operands +3.4028235E38 * -3.4028235E38 = -Infinity, with float field operands +3.4028235E38 / -3.4028235E38 = -1.0, with float field operands +3.4028235E38 + -3.4028235E38 = 0.0, with float a[i] operands +3.4028235E38 - -3.4028235E38 = Infinity, with float a[i] operands +3.4028235E38 * -3.4028235E38 = -Infinity, with float a[i] operands +3.4028235E38 / -3.4028235E38 = -1.0, with float a[i] operands +3.4028235E38 + -3.4028235E38 = 0.0, with float f(x) operands +3.4028235E38 - -3.4028235E38 = Infinity, with float f(x) operands +3.4028235E38 * -3.4028235E38 = -Infinity, with float f(x) operands +3.4028235E38 / -3.4028235E38 = -1.0, with float f(x) operands +3.4028235E38 + -3.4028235E38 = 0.0, with float lExpr operands +3.4028235E38 - -3.4028235E38 = Infinity, with float lExpr operands +3.4028235E38 * -3.4028235E38 = -Infinity, with float lExpr operands +3.4028235E38 / -3.4028235E38 = -1.0, with float lExpr operands +3.4028235E38 + -3.4028235E38 = 0.0, with float rExpr operands +3.4028235E38 - -3.4028235E38 = Infinity, with float rExpr operands +3.4028235E38 * -3.4028235E38 = -Infinity, with float rExpr operands +3.4028235E38 / -3.4028235E38 = -1.0, with float rExpr operands +3.4028235E38 + -3.4028235E38 = 0.0, with float exprs operands +3.4028235E38 - -3.4028235E38 = Infinity, with float exprs operands +3.4028235E38 * -3.4028235E38 = -Infinity, with float exprs operands +3.4028235E38 / -3.4028235E38 = -1.0, with float exprs operands +3.4028235E38 + -1.0 = 3.4028235E38, with float param operands +3.4028235E38 - -1.0 = 3.4028235E38, with float param operands +3.4028235E38 * -1.0 = -3.4028235E38, with float param operands +3.4028235E38 / -1.0 = -3.4028235E38, with float param operands +3.4028235E38 + -1.0 = 3.4028235E38, with float local operands +3.4028235E38 - -1.0 = 3.4028235E38, with float local operands +3.4028235E38 * -1.0 = -3.4028235E38, with float local operands +3.4028235E38 / -1.0 = -3.4028235E38, with float local operands +3.4028235E38 + -1.0 = 3.4028235E38, with float static operands +3.4028235E38 - -1.0 = 3.4028235E38, with float static operands +3.4028235E38 * -1.0 = -3.4028235E38, with float static operands +3.4028235E38 / -1.0 = -3.4028235E38, with float static operands +3.4028235E38 + -1.0 = 3.4028235E38, with float field operands +3.4028235E38 - -1.0 = 3.4028235E38, with float field operands +3.4028235E38 * -1.0 = -3.4028235E38, with float field operands +3.4028235E38 / -1.0 = -3.4028235E38, with float field operands +3.4028235E38 + -1.0 = 3.4028235E38, with float a[i] operands +3.4028235E38 - -1.0 = 3.4028235E38, with float a[i] operands +3.4028235E38 * -1.0 = -3.4028235E38, with float a[i] operands +3.4028235E38 / -1.0 = -3.4028235E38, with float a[i] operands +3.4028235E38 + -1.0 = 3.4028235E38, with float f(x) operands +3.4028235E38 - -1.0 = 3.4028235E38, with float f(x) operands +3.4028235E38 * -1.0 = -3.4028235E38, with float f(x) operands +3.4028235E38 / -1.0 = -3.4028235E38, with float f(x) operands +3.4028235E38 + -1.0 = 3.4028235E38, with float lExpr operands +3.4028235E38 - -1.0 = 3.4028235E38, with float lExpr operands +3.4028235E38 * -1.0 = -3.4028235E38, with float lExpr operands +3.4028235E38 / -1.0 = -3.4028235E38, with float lExpr operands +3.4028235E38 + -1.0 = 3.4028235E38, with float rExpr operands +3.4028235E38 - -1.0 = 3.4028235E38, with float rExpr operands +3.4028235E38 * -1.0 = -3.4028235E38, with float rExpr operands +3.4028235E38 / -1.0 = -3.4028235E38, with float rExpr operands +3.4028235E38 + -1.0 = 3.4028235E38, with float exprs operands +3.4028235E38 - -1.0 = 3.4028235E38, with float exprs operands +3.4028235E38 * -1.0 = -3.4028235E38, with float exprs operands +3.4028235E38 / -1.0 = -3.4028235E38, with float exprs operands +3.4028235E38 + 1.0 = 3.4028235E38, with float param operands +3.4028235E38 - 1.0 = 3.4028235E38, with float param operands +3.4028235E38 * 1.0 = 3.4028235E38, with float param operands +3.4028235E38 / 1.0 = 3.4028235E38, with float param operands +3.4028235E38 + 1.0 = 3.4028235E38, with float local operands +3.4028235E38 - 1.0 = 3.4028235E38, with float local operands +3.4028235E38 * 1.0 = 3.4028235E38, with float local operands +3.4028235E38 / 1.0 = 3.4028235E38, with float local operands +3.4028235E38 + 1.0 = 3.4028235E38, with float static operands +3.4028235E38 - 1.0 = 3.4028235E38, with float static operands +3.4028235E38 * 1.0 = 3.4028235E38, with float static operands +3.4028235E38 / 1.0 = 3.4028235E38, with float static operands +3.4028235E38 + 1.0 = 3.4028235E38, with float field operands +3.4028235E38 - 1.0 = 3.4028235E38, with float field operands +3.4028235E38 * 1.0 = 3.4028235E38, with float field operands +3.4028235E38 / 1.0 = 3.4028235E38, with float field operands +3.4028235E38 + 1.0 = 3.4028235E38, with float a[i] operands +3.4028235E38 - 1.0 = 3.4028235E38, with float a[i] operands +3.4028235E38 * 1.0 = 3.4028235E38, with float a[i] operands +3.4028235E38 / 1.0 = 3.4028235E38, with float a[i] operands +3.4028235E38 + 1.0 = 3.4028235E38, with float f(x) operands +3.4028235E38 - 1.0 = 3.4028235E38, with float f(x) operands +3.4028235E38 * 1.0 = 3.4028235E38, with float f(x) operands +3.4028235E38 / 1.0 = 3.4028235E38, with float f(x) operands +3.4028235E38 + 1.0 = 3.4028235E38, with float lExpr operands +3.4028235E38 - 1.0 = 3.4028235E38, with float lExpr operands +3.4028235E38 * 1.0 = 3.4028235E38, with float lExpr operands +3.4028235E38 / 1.0 = 3.4028235E38, with float lExpr operands +3.4028235E38 + 1.0 = 3.4028235E38, with float rExpr operands +3.4028235E38 - 1.0 = 3.4028235E38, with float rExpr operands +3.4028235E38 * 1.0 = 3.4028235E38, with float rExpr operands +3.4028235E38 / 1.0 = 3.4028235E38, with float rExpr operands +3.4028235E38 + 1.0 = 3.4028235E38, with float exprs operands +3.4028235E38 - 1.0 = 3.4028235E38, with float exprs operands +3.4028235E38 * 1.0 = 3.4028235E38, with float exprs operands +3.4028235E38 / 1.0 = 3.4028235E38, with float exprs operands +3.4028235E38 + -0.0 = 3.4028235E38, with float param operands +3.4028235E38 - -0.0 = 3.4028235E38, with float param operands +3.4028235E38 * -0.0 = -0.0, with float param operands +3.4028235E38 / -0.0 = -Infinity, with float param operands +3.4028235E38 + -0.0 = 3.4028235E38, with float local operands +3.4028235E38 - -0.0 = 3.4028235E38, with float local operands +3.4028235E38 * -0.0 = -0.0, with float local operands +3.4028235E38 / -0.0 = -Infinity, with float local operands +3.4028235E38 + -0.0 = 3.4028235E38, with float static operands +3.4028235E38 - -0.0 = 3.4028235E38, with float static operands +3.4028235E38 * -0.0 = -0.0, with float static operands +3.4028235E38 / -0.0 = -Infinity, with float static operands +3.4028235E38 + -0.0 = 3.4028235E38, with float field operands +3.4028235E38 - -0.0 = 3.4028235E38, with float field operands +3.4028235E38 * -0.0 = -0.0, with float field operands +3.4028235E38 / -0.0 = -Infinity, with float field operands +3.4028235E38 + -0.0 = 3.4028235E38, with float a[i] operands +3.4028235E38 - -0.0 = 3.4028235E38, with float a[i] operands +3.4028235E38 * -0.0 = -0.0, with float a[i] operands +3.4028235E38 / -0.0 = -Infinity, with float a[i] operands +3.4028235E38 + -0.0 = 3.4028235E38, with float f(x) operands +3.4028235E38 - -0.0 = 3.4028235E38, with float f(x) operands +3.4028235E38 * -0.0 = -0.0, with float f(x) operands +3.4028235E38 / -0.0 = -Infinity, with float f(x) operands +3.4028235E38 + -0.0 = 3.4028235E38, with float lExpr operands +3.4028235E38 - -0.0 = 3.4028235E38, with float lExpr operands +3.4028235E38 * -0.0 = -0.0, with float lExpr operands +3.4028235E38 / -0.0 = -Infinity, with float lExpr operands +3.4028235E38 + 0.0 = 3.4028235E38, with float rExpr operands +3.4028235E38 - 0.0 = 3.4028235E38, with float rExpr operands +3.4028235E38 * 0.0 = 0.0, with float rExpr operands +3.4028235E38 / 0.0 = Infinity, with float rExpr operands +3.4028235E38 + 0.0 = 3.4028235E38, with float exprs operands +3.4028235E38 - 0.0 = 3.4028235E38, with float exprs operands +3.4028235E38 * 0.0 = 0.0, with float exprs operands +3.4028235E38 / 0.0 = Infinity, with float exprs operands +3.4028235E38 + 0.0 = 3.4028235E38, with float param operands +3.4028235E38 - 0.0 = 3.4028235E38, with float param operands +3.4028235E38 * 0.0 = 0.0, with float param operands +3.4028235E38 / 0.0 = Infinity, with float param operands +3.4028235E38 + 0.0 = 3.4028235E38, with float local operands +3.4028235E38 - 0.0 = 3.4028235E38, with float local operands +3.4028235E38 * 0.0 = 0.0, with float local operands +3.4028235E38 / 0.0 = Infinity, with float local operands +3.4028235E38 + 0.0 = 3.4028235E38, with float static operands +3.4028235E38 - 0.0 = 3.4028235E38, with float static operands +3.4028235E38 * 0.0 = 0.0, with float static operands +3.4028235E38 / 0.0 = Infinity, with float static operands +3.4028235E38 + 0.0 = 3.4028235E38, with float field operands +3.4028235E38 - 0.0 = 3.4028235E38, with float field operands +3.4028235E38 * 0.0 = 0.0, with float field operands +3.4028235E38 / 0.0 = Infinity, with float field operands +3.4028235E38 + 0.0 = 3.4028235E38, with float a[i] operands +3.4028235E38 - 0.0 = 3.4028235E38, with float a[i] operands +3.4028235E38 * 0.0 = 0.0, with float a[i] operands +3.4028235E38 / 0.0 = Infinity, with float a[i] operands +3.4028235E38 + 0.0 = 3.4028235E38, with float f(x) operands +3.4028235E38 - 0.0 = 3.4028235E38, with float f(x) operands +3.4028235E38 * 0.0 = 0.0, with float f(x) operands +3.4028235E38 / 0.0 = Infinity, with float f(x) operands +3.4028235E38 + 0.0 = 3.4028235E38, with float lExpr operands +3.4028235E38 - 0.0 = 3.4028235E38, with float lExpr operands +3.4028235E38 * 0.0 = 0.0, with float lExpr operands +3.4028235E38 / 0.0 = Infinity, with float lExpr operands +3.4028235E38 + 0.0 = 3.4028235E38, with float rExpr operands +3.4028235E38 - 0.0 = 3.4028235E38, with float rExpr operands +3.4028235E38 * 0.0 = 0.0, with float rExpr operands +3.4028235E38 / 0.0 = Infinity, with float rExpr operands +3.4028235E38 + 0.0 = 3.4028235E38, with float exprs operands +3.4028235E38 - 0.0 = 3.4028235E38, with float exprs operands +3.4028235E38 * 0.0 = 0.0, with float exprs operands +3.4028235E38 / 0.0 = Infinity, with float exprs operands +3.4028235E38 + -Infinity = -Infinity, with float param operands +3.4028235E38 - -Infinity = Infinity, with float param operands +3.4028235E38 * -Infinity = -Infinity, with float param operands +3.4028235E38 / -Infinity = -0.0, with float param operands +3.4028235E38 + -Infinity = -Infinity, with float local operands +3.4028235E38 - -Infinity = Infinity, with float local operands +3.4028235E38 * -Infinity = -Infinity, with float local operands +3.4028235E38 / -Infinity = -0.0, with float local operands +3.4028235E38 + -Infinity = -Infinity, with float static operands +3.4028235E38 - -Infinity = Infinity, with float static operands +3.4028235E38 * -Infinity = -Infinity, with float static operands +3.4028235E38 / -Infinity = -0.0, with float static operands +3.4028235E38 + -Infinity = -Infinity, with float field operands +3.4028235E38 - -Infinity = Infinity, with float field operands +3.4028235E38 * -Infinity = -Infinity, with float field operands +3.4028235E38 / -Infinity = -0.0, with float field operands +3.4028235E38 + -Infinity = -Infinity, with float a[i] operands +3.4028235E38 - -Infinity = Infinity, with float a[i] operands +3.4028235E38 * -Infinity = -Infinity, with float a[i] operands +3.4028235E38 / -Infinity = -0.0, with float a[i] operands +3.4028235E38 + -Infinity = -Infinity, with float f(x) operands +3.4028235E38 - -Infinity = Infinity, with float f(x) operands +3.4028235E38 * -Infinity = -Infinity, with float f(x) operands +3.4028235E38 / -Infinity = -0.0, with float f(x) operands +3.4028235E38 + -Infinity = -Infinity, with float lExpr operands +3.4028235E38 - -Infinity = Infinity, with float lExpr operands +3.4028235E38 * -Infinity = -Infinity, with float lExpr operands +3.4028235E38 / -Infinity = -0.0, with float lExpr operands +3.4028235E38 + -Infinity = -Infinity, with float rExpr operands +3.4028235E38 - -Infinity = Infinity, with float rExpr operands +3.4028235E38 * -Infinity = -Infinity, with float rExpr operands +3.4028235E38 / -Infinity = -0.0, with float rExpr operands +3.4028235E38 + -Infinity = -Infinity, with float exprs operands +3.4028235E38 - -Infinity = Infinity, with float exprs operands +3.4028235E38 * -Infinity = -Infinity, with float exprs operands +3.4028235E38 / -Infinity = -0.0, with float exprs operands +3.4028235E38 + Infinity = Infinity, with float param operands +3.4028235E38 - Infinity = -Infinity, with float param operands +3.4028235E38 * Infinity = Infinity, with float param operands +3.4028235E38 / Infinity = 0.0, with float param operands +3.4028235E38 + Infinity = Infinity, with float local operands +3.4028235E38 - Infinity = -Infinity, with float local operands +3.4028235E38 * Infinity = Infinity, with float local operands +3.4028235E38 / Infinity = 0.0, with float local operands +3.4028235E38 + Infinity = Infinity, with float static operands +3.4028235E38 - Infinity = -Infinity, with float static operands +3.4028235E38 * Infinity = Infinity, with float static operands +3.4028235E38 / Infinity = 0.0, with float static operands +3.4028235E38 + Infinity = Infinity, with float field operands +3.4028235E38 - Infinity = -Infinity, with float field operands +3.4028235E38 * Infinity = Infinity, with float field operands +3.4028235E38 / Infinity = 0.0, with float field operands +3.4028235E38 + Infinity = Infinity, with float a[i] operands +3.4028235E38 - Infinity = -Infinity, with float a[i] operands +3.4028235E38 * Infinity = Infinity, with float a[i] operands +3.4028235E38 / Infinity = 0.0, with float a[i] operands +3.4028235E38 + Infinity = Infinity, with float f(x) operands +3.4028235E38 - Infinity = -Infinity, with float f(x) operands +3.4028235E38 * Infinity = Infinity, with float f(x) operands +3.4028235E38 / Infinity = 0.0, with float f(x) operands +3.4028235E38 + Infinity = Infinity, with float lExpr operands +3.4028235E38 - Infinity = -Infinity, with float lExpr operands +3.4028235E38 * Infinity = Infinity, with float lExpr operands +3.4028235E38 / Infinity = 0.0, with float lExpr operands +3.4028235E38 + Infinity = Infinity, with float rExpr operands +3.4028235E38 - Infinity = -Infinity, with float rExpr operands +3.4028235E38 * Infinity = Infinity, with float rExpr operands +3.4028235E38 / Infinity = 0.0, with float rExpr operands +3.4028235E38 + Infinity = Infinity, with float exprs operands +3.4028235E38 - Infinity = -Infinity, with float exprs operands +3.4028235E38 * Infinity = Infinity, with float exprs operands +3.4028235E38 / Infinity = 0.0, with float exprs operands +3.4028235E38 + NaN = NaN, with float param operands +3.4028235E38 - NaN = NaN, with float param operands +3.4028235E38 * NaN = NaN, with float param operands +3.4028235E38 / NaN = NaN, with float param operands +3.4028235E38 + NaN = NaN, with float local operands +3.4028235E38 - NaN = NaN, with float local operands +3.4028235E38 * NaN = NaN, with float local operands +3.4028235E38 / NaN = NaN, with float local operands +3.4028235E38 + NaN = NaN, with float static operands +3.4028235E38 - NaN = NaN, with float static operands +3.4028235E38 * NaN = NaN, with float static operands +3.4028235E38 / NaN = NaN, with float static operands +3.4028235E38 + NaN = NaN, with float field operands +3.4028235E38 - NaN = NaN, with float field operands +3.4028235E38 * NaN = NaN, with float field operands +3.4028235E38 / NaN = NaN, with float field operands +3.4028235E38 + NaN = NaN, with float a[i] operands +3.4028235E38 - NaN = NaN, with float a[i] operands +3.4028235E38 * NaN = NaN, with float a[i] operands +3.4028235E38 / NaN = NaN, with float a[i] operands +3.4028235E38 + NaN = NaN, with float f(x) operands +3.4028235E38 - NaN = NaN, with float f(x) operands +3.4028235E38 * NaN = NaN, with float f(x) operands +3.4028235E38 / NaN = NaN, with float f(x) operands +3.4028235E38 + NaN = NaN, with float lExpr operands +3.4028235E38 - NaN = NaN, with float lExpr operands +3.4028235E38 * NaN = NaN, with float lExpr operands +3.4028235E38 / NaN = NaN, with float lExpr operands +3.4028235E38 + NaN = NaN, with float rExpr operands +3.4028235E38 - NaN = NaN, with float rExpr operands +3.4028235E38 * NaN = NaN, with float rExpr operands +3.4028235E38 / NaN = NaN, with float rExpr operands +3.4028235E38 + NaN = NaN, with float exprs operands +3.4028235E38 - NaN = NaN, with float exprs operands +3.4028235E38 * NaN = NaN, with float exprs operands +3.4028235E38 / NaN = NaN, with float exprs operands +-1.4E-45 + 1.4E-45 = 0.0, with float param operands +-1.4E-45 - 1.4E-45 = -2.8E-45, with float param operands +-1.4E-45 * 1.4E-45 = -0.0, with float param operands +-1.4E-45 / 1.4E-45 = -1.0, with float param operands +-1.4E-45 + 1.4E-45 = 0.0, with float local operands +-1.4E-45 - 1.4E-45 = -2.8E-45, with float local operands +-1.4E-45 * 1.4E-45 = -0.0, with float local operands +-1.4E-45 / 1.4E-45 = -1.0, with float local operands +-1.4E-45 + 1.4E-45 = 0.0, with float static operands +-1.4E-45 - 1.4E-45 = -2.8E-45, with float static operands +-1.4E-45 * 1.4E-45 = -0.0, with float static operands +-1.4E-45 / 1.4E-45 = -1.0, with float static operands +-1.4E-45 + 1.4E-45 = 0.0, with float field operands +-1.4E-45 - 1.4E-45 = -2.8E-45, with float field operands +-1.4E-45 * 1.4E-45 = -0.0, with float field operands +-1.4E-45 / 1.4E-45 = -1.0, with float field operands +-1.4E-45 + 1.4E-45 = 0.0, with float a[i] operands +-1.4E-45 - 1.4E-45 = -2.8E-45, with float a[i] operands +-1.4E-45 * 1.4E-45 = -0.0, with float a[i] operands +-1.4E-45 / 1.4E-45 = -1.0, with float a[i] operands +-1.4E-45 + 1.4E-45 = 0.0, with float f(x) operands +-1.4E-45 - 1.4E-45 = -2.8E-45, with float f(x) operands +-1.4E-45 * 1.4E-45 = -0.0, with float f(x) operands +-1.4E-45 / 1.4E-45 = -1.0, with float f(x) operands +-1.4E-45 + 1.4E-45 = 0.0, with float lExpr operands +-1.4E-45 - 1.4E-45 = -2.8E-45, with float lExpr operands +-1.4E-45 * 1.4E-45 = -0.0, with float lExpr operands +-1.4E-45 / 1.4E-45 = -1.0, with float lExpr operands +-1.4E-45 + 1.4E-45 = 0.0, with float rExpr operands +-1.4E-45 - 1.4E-45 = -2.8E-45, with float rExpr operands +-1.4E-45 * 1.4E-45 = -0.0, with float rExpr operands +-1.4E-45 / 1.4E-45 = -1.0, with float rExpr operands +-1.4E-45 + 1.4E-45 = 0.0, with float exprs operands +-1.4E-45 - 1.4E-45 = -2.8E-45, with float exprs operands +-1.4E-45 * 1.4E-45 = -0.0, with float exprs operands +-1.4E-45 / 1.4E-45 = -1.0, with float exprs operands +-1.4E-45 + 3.4028235E38 = 3.4028235E38, with float param operands +-1.4E-45 - 3.4028235E38 = -3.4028235E38, with float param operands +-1.4E-45 * 3.4028235E38 = -4.7683713E-7, with float param operands +-1.4E-45 / 3.4028235E38 = -0.0, with float param operands +-1.4E-45 + 3.4028235E38 = 3.4028235E38, with float local operands +-1.4E-45 - 3.4028235E38 = -3.4028235E38, with float local operands +-1.4E-45 * 3.4028235E38 = -4.7683713E-7, with float local operands +-1.4E-45 / 3.4028235E38 = -0.0, with float local operands +-1.4E-45 + 3.4028235E38 = 3.4028235E38, with float static operands +-1.4E-45 - 3.4028235E38 = -3.4028235E38, with float static operands +-1.4E-45 * 3.4028235E38 = -4.7683713E-7, with float static operands +-1.4E-45 / 3.4028235E38 = -0.0, with float static operands +-1.4E-45 + 3.4028235E38 = 3.4028235E38, with float field operands +-1.4E-45 - 3.4028235E38 = -3.4028235E38, with float field operands +-1.4E-45 * 3.4028235E38 = -4.7683713E-7, with float field operands +-1.4E-45 / 3.4028235E38 = -0.0, with float field operands +-1.4E-45 + 3.4028235E38 = 3.4028235E38, with float a[i] operands +-1.4E-45 - 3.4028235E38 = -3.4028235E38, with float a[i] operands +-1.4E-45 * 3.4028235E38 = -4.7683713E-7, with float a[i] operands +-1.4E-45 / 3.4028235E38 = -0.0, with float a[i] operands +-1.4E-45 + 3.4028235E38 = 3.4028235E38, with float f(x) operands +-1.4E-45 - 3.4028235E38 = -3.4028235E38, with float f(x) operands +-1.4E-45 * 3.4028235E38 = -4.7683713E-7, with float f(x) operands +-1.4E-45 / 3.4028235E38 = -0.0, with float f(x) operands +-1.4E-45 + 3.4028235E38 = 3.4028235E38, with float lExpr operands +-1.4E-45 - 3.4028235E38 = -3.4028235E38, with float lExpr operands +-1.4E-45 * 3.4028235E38 = -4.7683713E-7, with float lExpr operands +-1.4E-45 / 3.4028235E38 = -0.0, with float lExpr operands +-1.4E-45 + 3.4028235E38 = 3.4028235E38, with float rExpr operands +-1.4E-45 - 3.4028235E38 = -3.4028235E38, with float rExpr operands +-1.4E-45 * 3.4028235E38 = -4.7683713E-7, with float rExpr operands +-1.4E-45 / 3.4028235E38 = -0.0, with float rExpr operands +-1.4E-45 + 3.4028235E38 = 3.4028235E38, with float exprs operands +-1.4E-45 - 3.4028235E38 = -3.4028235E38, with float exprs operands +-1.4E-45 * 3.4028235E38 = -4.7683713E-7, with float exprs operands +-1.4E-45 / 3.4028235E38 = -0.0, with float exprs operands +-1.4E-45 + -1.4E-45 = -2.8E-45, with float param operands +-1.4E-45 - -1.4E-45 = 0.0, with float param operands +-1.4E-45 * -1.4E-45 = 0.0, with float param operands +-1.4E-45 / -1.4E-45 = 1.0, with float param operands +-1.4E-45 + -1.4E-45 = -2.8E-45, with float local operands +-1.4E-45 - -1.4E-45 = 0.0, with float local operands +-1.4E-45 * -1.4E-45 = 0.0, with float local operands +-1.4E-45 / -1.4E-45 = 1.0, with float local operands +-1.4E-45 + -1.4E-45 = -2.8E-45, with float static operands +-1.4E-45 - -1.4E-45 = 0.0, with float static operands +-1.4E-45 * -1.4E-45 = 0.0, with float static operands +-1.4E-45 / -1.4E-45 = 1.0, with float static operands +-1.4E-45 + -1.4E-45 = -2.8E-45, with float field operands +-1.4E-45 - -1.4E-45 = 0.0, with float field operands +-1.4E-45 * -1.4E-45 = 0.0, with float field operands +-1.4E-45 / -1.4E-45 = 1.0, with float field operands +-1.4E-45 + -1.4E-45 = -2.8E-45, with float a[i] operands +-1.4E-45 - -1.4E-45 = 0.0, with float a[i] operands +-1.4E-45 * -1.4E-45 = 0.0, with float a[i] operands +-1.4E-45 / -1.4E-45 = 1.0, with float a[i] operands +-1.4E-45 + -1.4E-45 = -2.8E-45, with float f(x) operands +-1.4E-45 - -1.4E-45 = 0.0, with float f(x) operands +-1.4E-45 * -1.4E-45 = 0.0, with float f(x) operands +-1.4E-45 / -1.4E-45 = 1.0, with float f(x) operands +-1.4E-45 + -1.4E-45 = -2.8E-45, with float lExpr operands +-1.4E-45 - -1.4E-45 = 0.0, with float lExpr operands +-1.4E-45 * -1.4E-45 = 0.0, with float lExpr operands +-1.4E-45 / -1.4E-45 = 1.0, with float lExpr operands +-1.4E-45 + -1.4E-45 = -2.8E-45, with float rExpr operands +-1.4E-45 - -1.4E-45 = 0.0, with float rExpr operands +-1.4E-45 * -1.4E-45 = 0.0, with float rExpr operands +-1.4E-45 / -1.4E-45 = 1.0, with float rExpr operands +-1.4E-45 + -1.4E-45 = -2.8E-45, with float exprs operands +-1.4E-45 - -1.4E-45 = 0.0, with float exprs operands +-1.4E-45 * -1.4E-45 = 0.0, with float exprs operands +-1.4E-45 / -1.4E-45 = 1.0, with float exprs operands +-1.4E-45 + -3.4028235E38 = -3.4028235E38, with float param operands +-1.4E-45 - -3.4028235E38 = 3.4028235E38, with float param operands +-1.4E-45 * -3.4028235E38 = 4.7683713E-7, with float param operands +-1.4E-45 / -3.4028235E38 = 0.0, with float param operands +-1.4E-45 + -3.4028235E38 = -3.4028235E38, with float local operands +-1.4E-45 - -3.4028235E38 = 3.4028235E38, with float local operands +-1.4E-45 * -3.4028235E38 = 4.7683713E-7, with float local operands +-1.4E-45 / -3.4028235E38 = 0.0, with float local operands +-1.4E-45 + -3.4028235E38 = -3.4028235E38, with float static operands +-1.4E-45 - -3.4028235E38 = 3.4028235E38, with float static operands +-1.4E-45 * -3.4028235E38 = 4.7683713E-7, with float static operands +-1.4E-45 / -3.4028235E38 = 0.0, with float static operands +-1.4E-45 + -3.4028235E38 = -3.4028235E38, with float field operands +-1.4E-45 - -3.4028235E38 = 3.4028235E38, with float field operands +-1.4E-45 * -3.4028235E38 = 4.7683713E-7, with float field operands +-1.4E-45 / -3.4028235E38 = 0.0, with float field operands +-1.4E-45 + -3.4028235E38 = -3.4028235E38, with float a[i] operands +-1.4E-45 - -3.4028235E38 = 3.4028235E38, with float a[i] operands +-1.4E-45 * -3.4028235E38 = 4.7683713E-7, with float a[i] operands +-1.4E-45 / -3.4028235E38 = 0.0, with float a[i] operands +-1.4E-45 + -3.4028235E38 = -3.4028235E38, with float f(x) operands +-1.4E-45 - -3.4028235E38 = 3.4028235E38, with float f(x) operands +-1.4E-45 * -3.4028235E38 = 4.7683713E-7, with float f(x) operands +-1.4E-45 / -3.4028235E38 = 0.0, with float f(x) operands +-1.4E-45 + -3.4028235E38 = -3.4028235E38, with float lExpr operands +-1.4E-45 - -3.4028235E38 = 3.4028235E38, with float lExpr operands +-1.4E-45 * -3.4028235E38 = 4.7683713E-7, with float lExpr operands +-1.4E-45 / -3.4028235E38 = 0.0, with float lExpr operands +-1.4E-45 + -3.4028235E38 = -3.4028235E38, with float rExpr operands +-1.4E-45 - -3.4028235E38 = 3.4028235E38, with float rExpr operands +-1.4E-45 * -3.4028235E38 = 4.7683713E-7, with float rExpr operands +-1.4E-45 / -3.4028235E38 = 0.0, with float rExpr operands +-1.4E-45 + -3.4028235E38 = -3.4028235E38, with float exprs operands +-1.4E-45 - -3.4028235E38 = 3.4028235E38, with float exprs operands +-1.4E-45 * -3.4028235E38 = 4.7683713E-7, with float exprs operands +-1.4E-45 / -3.4028235E38 = 0.0, with float exprs operands +-1.4E-45 + -1.0 = -1.0, with float param operands +-1.4E-45 - -1.0 = 1.0, with float param operands +-1.4E-45 * -1.0 = 1.4E-45, with float param operands +-1.4E-45 / -1.0 = 1.4E-45, with float param operands +-1.4E-45 + -1.0 = -1.0, with float local operands +-1.4E-45 - -1.0 = 1.0, with float local operands +-1.4E-45 * -1.0 = 1.4E-45, with float local operands +-1.4E-45 / -1.0 = 1.4E-45, with float local operands +-1.4E-45 + -1.0 = -1.0, with float static operands +-1.4E-45 - -1.0 = 1.0, with float static operands +-1.4E-45 * -1.0 = 1.4E-45, with float static operands +-1.4E-45 / -1.0 = 1.4E-45, with float static operands +-1.4E-45 + -1.0 = -1.0, with float field operands +-1.4E-45 - -1.0 = 1.0, with float field operands +-1.4E-45 * -1.0 = 1.4E-45, with float field operands +-1.4E-45 / -1.0 = 1.4E-45, with float field operands +-1.4E-45 + -1.0 = -1.0, with float a[i] operands +-1.4E-45 - -1.0 = 1.0, with float a[i] operands +-1.4E-45 * -1.0 = 1.4E-45, with float a[i] operands +-1.4E-45 / -1.0 = 1.4E-45, with float a[i] operands +-1.4E-45 + -1.0 = -1.0, with float f(x) operands +-1.4E-45 - -1.0 = 1.0, with float f(x) operands +-1.4E-45 * -1.0 = 1.4E-45, with float f(x) operands +-1.4E-45 / -1.0 = 1.4E-45, with float f(x) operands +-1.4E-45 + -1.0 = -1.0, with float lExpr operands +-1.4E-45 - -1.0 = 1.0, with float lExpr operands +-1.4E-45 * -1.0 = 1.4E-45, with float lExpr operands +-1.4E-45 / -1.0 = 1.4E-45, with float lExpr operands +-1.4E-45 + -1.0 = -1.0, with float rExpr operands +-1.4E-45 - -1.0 = 1.0, with float rExpr operands +-1.4E-45 * -1.0 = 1.4E-45, with float rExpr operands +-1.4E-45 / -1.0 = 1.4E-45, with float rExpr operands +-1.4E-45 + -1.0 = -1.0, with float exprs operands +-1.4E-45 - -1.0 = 1.0, with float exprs operands +-1.4E-45 * -1.0 = 1.4E-45, with float exprs operands +-1.4E-45 / -1.0 = 1.4E-45, with float exprs operands +-1.4E-45 + 1.0 = 1.0, with float param operands +-1.4E-45 - 1.0 = -1.0, with float param operands +-1.4E-45 * 1.0 = -1.4E-45, with float param operands +-1.4E-45 / 1.0 = -1.4E-45, with float param operands +-1.4E-45 + 1.0 = 1.0, with float local operands +-1.4E-45 - 1.0 = -1.0, with float local operands +-1.4E-45 * 1.0 = -1.4E-45, with float local operands +-1.4E-45 / 1.0 = -1.4E-45, with float local operands +-1.4E-45 + 1.0 = 1.0, with float static operands +-1.4E-45 - 1.0 = -1.0, with float static operands +-1.4E-45 * 1.0 = -1.4E-45, with float static operands +-1.4E-45 / 1.0 = -1.4E-45, with float static operands +-1.4E-45 + 1.0 = 1.0, with float field operands +-1.4E-45 - 1.0 = -1.0, with float field operands +-1.4E-45 * 1.0 = -1.4E-45, with float field operands +-1.4E-45 / 1.0 = -1.4E-45, with float field operands +-1.4E-45 + 1.0 = 1.0, with float a[i] operands +-1.4E-45 - 1.0 = -1.0, with float a[i] operands +-1.4E-45 * 1.0 = -1.4E-45, with float a[i] operands +-1.4E-45 / 1.0 = -1.4E-45, with float a[i] operands +-1.4E-45 + 1.0 = 1.0, with float f(x) operands +-1.4E-45 - 1.0 = -1.0, with float f(x) operands +-1.4E-45 * 1.0 = -1.4E-45, with float f(x) operands +-1.4E-45 / 1.0 = -1.4E-45, with float f(x) operands +-1.4E-45 + 1.0 = 1.0, with float lExpr operands +-1.4E-45 - 1.0 = -1.0, with float lExpr operands +-1.4E-45 * 1.0 = -1.4E-45, with float lExpr operands +-1.4E-45 / 1.0 = -1.4E-45, with float lExpr operands +-1.4E-45 + 1.0 = 1.0, with float rExpr operands +-1.4E-45 - 1.0 = -1.0, with float rExpr operands +-1.4E-45 * 1.0 = -1.4E-45, with float rExpr operands +-1.4E-45 / 1.0 = -1.4E-45, with float rExpr operands +-1.4E-45 + 1.0 = 1.0, with float exprs operands +-1.4E-45 - 1.0 = -1.0, with float exprs operands +-1.4E-45 * 1.0 = -1.4E-45, with float exprs operands +-1.4E-45 / 1.0 = -1.4E-45, with float exprs operands +-1.4E-45 + -0.0 = -1.4E-45, with float param operands +-1.4E-45 - -0.0 = -1.4E-45, with float param operands +-1.4E-45 * -0.0 = 0.0, with float param operands +-1.4E-45 / -0.0 = Infinity, with float param operands +-1.4E-45 + -0.0 = -1.4E-45, with float local operands +-1.4E-45 - -0.0 = -1.4E-45, with float local operands +-1.4E-45 * -0.0 = 0.0, with float local operands +-1.4E-45 / -0.0 = Infinity, with float local operands +-1.4E-45 + -0.0 = -1.4E-45, with float static operands +-1.4E-45 - -0.0 = -1.4E-45, with float static operands +-1.4E-45 * -0.0 = 0.0, with float static operands +-1.4E-45 / -0.0 = Infinity, with float static operands +-1.4E-45 + -0.0 = -1.4E-45, with float field operands +-1.4E-45 - -0.0 = -1.4E-45, with float field operands +-1.4E-45 * -0.0 = 0.0, with float field operands +-1.4E-45 / -0.0 = Infinity, with float field operands +-1.4E-45 + -0.0 = -1.4E-45, with float a[i] operands +-1.4E-45 - -0.0 = -1.4E-45, with float a[i] operands +-1.4E-45 * -0.0 = 0.0, with float a[i] operands +-1.4E-45 / -0.0 = Infinity, with float a[i] operands +-1.4E-45 + -0.0 = -1.4E-45, with float f(x) operands +-1.4E-45 - -0.0 = -1.4E-45, with float f(x) operands +-1.4E-45 * -0.0 = 0.0, with float f(x) operands +-1.4E-45 / -0.0 = Infinity, with float f(x) operands +-1.4E-45 + -0.0 = -1.4E-45, with float lExpr operands +-1.4E-45 - -0.0 = -1.4E-45, with float lExpr operands +-1.4E-45 * -0.0 = 0.0, with float lExpr operands +-1.4E-45 / -0.0 = Infinity, with float lExpr operands +-1.4E-45 + 0.0 = -1.4E-45, with float rExpr operands +-1.4E-45 - 0.0 = -1.4E-45, with float rExpr operands +-1.4E-45 * 0.0 = -0.0, with float rExpr operands +-1.4E-45 / 0.0 = -Infinity, with float rExpr operands +-1.4E-45 + 0.0 = -1.4E-45, with float exprs operands +-1.4E-45 - 0.0 = -1.4E-45, with float exprs operands +-1.4E-45 * 0.0 = -0.0, with float exprs operands +-1.4E-45 / 0.0 = -Infinity, with float exprs operands +-1.4E-45 + 0.0 = -1.4E-45, with float param operands +-1.4E-45 - 0.0 = -1.4E-45, with float param operands +-1.4E-45 * 0.0 = -0.0, with float param operands +-1.4E-45 / 0.0 = -Infinity, with float param operands +-1.4E-45 + 0.0 = -1.4E-45, with float local operands +-1.4E-45 - 0.0 = -1.4E-45, with float local operands +-1.4E-45 * 0.0 = -0.0, with float local operands +-1.4E-45 / 0.0 = -Infinity, with float local operands +-1.4E-45 + 0.0 = -1.4E-45, with float static operands +-1.4E-45 - 0.0 = -1.4E-45, with float static operands +-1.4E-45 * 0.0 = -0.0, with float static operands +-1.4E-45 / 0.0 = -Infinity, with float static operands +-1.4E-45 + 0.0 = -1.4E-45, with float field operands +-1.4E-45 - 0.0 = -1.4E-45, with float field operands +-1.4E-45 * 0.0 = -0.0, with float field operands +-1.4E-45 / 0.0 = -Infinity, with float field operands +-1.4E-45 + 0.0 = -1.4E-45, with float a[i] operands +-1.4E-45 - 0.0 = -1.4E-45, with float a[i] operands +-1.4E-45 * 0.0 = -0.0, with float a[i] operands +-1.4E-45 / 0.0 = -Infinity, with float a[i] operands +-1.4E-45 + 0.0 = -1.4E-45, with float f(x) operands +-1.4E-45 - 0.0 = -1.4E-45, with float f(x) operands +-1.4E-45 * 0.0 = -0.0, with float f(x) operands +-1.4E-45 / 0.0 = -Infinity, with float f(x) operands +-1.4E-45 + 0.0 = -1.4E-45, with float lExpr operands +-1.4E-45 - 0.0 = -1.4E-45, with float lExpr operands +-1.4E-45 * 0.0 = -0.0, with float lExpr operands +-1.4E-45 / 0.0 = -Infinity, with float lExpr operands +-1.4E-45 + 0.0 = -1.4E-45, with float rExpr operands +-1.4E-45 - 0.0 = -1.4E-45, with float rExpr operands +-1.4E-45 * 0.0 = -0.0, with float rExpr operands +-1.4E-45 / 0.0 = -Infinity, with float rExpr operands +-1.4E-45 + 0.0 = -1.4E-45, with float exprs operands +-1.4E-45 - 0.0 = -1.4E-45, with float exprs operands +-1.4E-45 * 0.0 = -0.0, with float exprs operands +-1.4E-45 / 0.0 = -Infinity, with float exprs operands +-1.4E-45 + -Infinity = -Infinity, with float param operands +-1.4E-45 - -Infinity = Infinity, with float param operands +-1.4E-45 * -Infinity = Infinity, with float param operands +-1.4E-45 / -Infinity = 0.0, with float param operands +-1.4E-45 + -Infinity = -Infinity, with float local operands +-1.4E-45 - -Infinity = Infinity, with float local operands +-1.4E-45 * -Infinity = Infinity, with float local operands +-1.4E-45 / -Infinity = 0.0, with float local operands +-1.4E-45 + -Infinity = -Infinity, with float static operands +-1.4E-45 - -Infinity = Infinity, with float static operands +-1.4E-45 * -Infinity = Infinity, with float static operands +-1.4E-45 / -Infinity = 0.0, with float static operands +-1.4E-45 + -Infinity = -Infinity, with float field operands +-1.4E-45 - -Infinity = Infinity, with float field operands +-1.4E-45 * -Infinity = Infinity, with float field operands +-1.4E-45 / -Infinity = 0.0, with float field operands +-1.4E-45 + -Infinity = -Infinity, with float a[i] operands +-1.4E-45 - -Infinity = Infinity, with float a[i] operands +-1.4E-45 * -Infinity = Infinity, with float a[i] operands +-1.4E-45 / -Infinity = 0.0, with float a[i] operands +-1.4E-45 + -Infinity = -Infinity, with float f(x) operands +-1.4E-45 - -Infinity = Infinity, with float f(x) operands +-1.4E-45 * -Infinity = Infinity, with float f(x) operands +-1.4E-45 / -Infinity = 0.0, with float f(x) operands +-1.4E-45 + -Infinity = -Infinity, with float lExpr operands +-1.4E-45 - -Infinity = Infinity, with float lExpr operands +-1.4E-45 * -Infinity = Infinity, with float lExpr operands +-1.4E-45 / -Infinity = 0.0, with float lExpr operands +-1.4E-45 + -Infinity = -Infinity, with float rExpr operands +-1.4E-45 - -Infinity = Infinity, with float rExpr operands +-1.4E-45 * -Infinity = Infinity, with float rExpr operands +-1.4E-45 / -Infinity = 0.0, with float rExpr operands +-1.4E-45 + -Infinity = -Infinity, with float exprs operands +-1.4E-45 - -Infinity = Infinity, with float exprs operands +-1.4E-45 * -Infinity = Infinity, with float exprs operands +-1.4E-45 / -Infinity = 0.0, with float exprs operands +-1.4E-45 + Infinity = Infinity, with float param operands +-1.4E-45 - Infinity = -Infinity, with float param operands +-1.4E-45 * Infinity = -Infinity, with float param operands +-1.4E-45 / Infinity = -0.0, with float param operands +-1.4E-45 + Infinity = Infinity, with float local operands +-1.4E-45 - Infinity = -Infinity, with float local operands +-1.4E-45 * Infinity = -Infinity, with float local operands +-1.4E-45 / Infinity = -0.0, with float local operands +-1.4E-45 + Infinity = Infinity, with float static operands +-1.4E-45 - Infinity = -Infinity, with float static operands +-1.4E-45 * Infinity = -Infinity, with float static operands +-1.4E-45 / Infinity = -0.0, with float static operands +-1.4E-45 + Infinity = Infinity, with float field operands +-1.4E-45 - Infinity = -Infinity, with float field operands +-1.4E-45 * Infinity = -Infinity, with float field operands +-1.4E-45 / Infinity = -0.0, with float field operands +-1.4E-45 + Infinity = Infinity, with float a[i] operands +-1.4E-45 - Infinity = -Infinity, with float a[i] operands +-1.4E-45 * Infinity = -Infinity, with float a[i] operands +-1.4E-45 / Infinity = -0.0, with float a[i] operands +-1.4E-45 + Infinity = Infinity, with float f(x) operands +-1.4E-45 - Infinity = -Infinity, with float f(x) operands +-1.4E-45 * Infinity = -Infinity, with float f(x) operands +-1.4E-45 / Infinity = -0.0, with float f(x) operands +-1.4E-45 + Infinity = Infinity, with float lExpr operands +-1.4E-45 - Infinity = -Infinity, with float lExpr operands +-1.4E-45 * Infinity = -Infinity, with float lExpr operands +-1.4E-45 / Infinity = -0.0, with float lExpr operands +-1.4E-45 + Infinity = Infinity, with float rExpr operands +-1.4E-45 - Infinity = -Infinity, with float rExpr operands +-1.4E-45 * Infinity = -Infinity, with float rExpr operands +-1.4E-45 / Infinity = -0.0, with float rExpr operands +-1.4E-45 + Infinity = Infinity, with float exprs operands +-1.4E-45 - Infinity = -Infinity, with float exprs operands +-1.4E-45 * Infinity = -Infinity, with float exprs operands +-1.4E-45 / Infinity = -0.0, with float exprs operands +-1.4E-45 + NaN = NaN, with float param operands +-1.4E-45 - NaN = NaN, with float param operands +-1.4E-45 * NaN = NaN, with float param operands +-1.4E-45 / NaN = NaN, with float param operands +-1.4E-45 + NaN = NaN, with float local operands +-1.4E-45 - NaN = NaN, with float local operands +-1.4E-45 * NaN = NaN, with float local operands +-1.4E-45 / NaN = NaN, with float local operands +-1.4E-45 + NaN = NaN, with float static operands +-1.4E-45 - NaN = NaN, with float static operands +-1.4E-45 * NaN = NaN, with float static operands +-1.4E-45 / NaN = NaN, with float static operands +-1.4E-45 + NaN = NaN, with float field operands +-1.4E-45 - NaN = NaN, with float field operands +-1.4E-45 * NaN = NaN, with float field operands +-1.4E-45 / NaN = NaN, with float field operands +-1.4E-45 + NaN = NaN, with float a[i] operands +-1.4E-45 - NaN = NaN, with float a[i] operands +-1.4E-45 * NaN = NaN, with float a[i] operands +-1.4E-45 / NaN = NaN, with float a[i] operands +-1.4E-45 + NaN = NaN, with float f(x) operands +-1.4E-45 - NaN = NaN, with float f(x) operands +-1.4E-45 * NaN = NaN, with float f(x) operands +-1.4E-45 / NaN = NaN, with float f(x) operands +-1.4E-45 + NaN = NaN, with float lExpr operands +-1.4E-45 - NaN = NaN, with float lExpr operands +-1.4E-45 * NaN = NaN, with float lExpr operands +-1.4E-45 / NaN = NaN, with float lExpr operands +-1.4E-45 + NaN = NaN, with float rExpr operands +-1.4E-45 - NaN = NaN, with float rExpr operands +-1.4E-45 * NaN = NaN, with float rExpr operands +-1.4E-45 / NaN = NaN, with float rExpr operands +-1.4E-45 + NaN = NaN, with float exprs operands +-1.4E-45 - NaN = NaN, with float exprs operands +-1.4E-45 * NaN = NaN, with float exprs operands +-1.4E-45 / NaN = NaN, with float exprs operands +-3.4028235E38 + 1.4E-45 = -3.4028235E38, with float param operands +-3.4028235E38 - 1.4E-45 = -3.4028235E38, with float param operands +-3.4028235E38 * 1.4E-45 = -4.7683713E-7, with float param operands +-3.4028235E38 / 1.4E-45 = -Infinity, with float param operands +-3.4028235E38 + 1.4E-45 = -3.4028235E38, with float local operands +-3.4028235E38 - 1.4E-45 = -3.4028235E38, with float local operands +-3.4028235E38 * 1.4E-45 = -4.7683713E-7, with float local operands +-3.4028235E38 / 1.4E-45 = -Infinity, with float local operands +-3.4028235E38 + 1.4E-45 = -3.4028235E38, with float static operands +-3.4028235E38 - 1.4E-45 = -3.4028235E38, with float static operands +-3.4028235E38 * 1.4E-45 = -4.7683713E-7, with float static operands +-3.4028235E38 / 1.4E-45 = -Infinity, with float static operands +-3.4028235E38 + 1.4E-45 = -3.4028235E38, with float field operands +-3.4028235E38 - 1.4E-45 = -3.4028235E38, with float field operands +-3.4028235E38 * 1.4E-45 = -4.7683713E-7, with float field operands +-3.4028235E38 / 1.4E-45 = -Infinity, with float field operands +-3.4028235E38 + 1.4E-45 = -3.4028235E38, with float a[i] operands +-3.4028235E38 - 1.4E-45 = -3.4028235E38, with float a[i] operands +-3.4028235E38 * 1.4E-45 = -4.7683713E-7, with float a[i] operands +-3.4028235E38 / 1.4E-45 = -Infinity, with float a[i] operands +-3.4028235E38 + 1.4E-45 = -3.4028235E38, with float f(x) operands +-3.4028235E38 - 1.4E-45 = -3.4028235E38, with float f(x) operands +-3.4028235E38 * 1.4E-45 = -4.7683713E-7, with float f(x) operands +-3.4028235E38 / 1.4E-45 = -Infinity, with float f(x) operands +-3.4028235E38 + 1.4E-45 = -3.4028235E38, with float lExpr operands +-3.4028235E38 - 1.4E-45 = -3.4028235E38, with float lExpr operands +-3.4028235E38 * 1.4E-45 = -4.7683713E-7, with float lExpr operands +-3.4028235E38 / 1.4E-45 = -Infinity, with float lExpr operands +-3.4028235E38 + 1.4E-45 = -3.4028235E38, with float rExpr operands +-3.4028235E38 - 1.4E-45 = -3.4028235E38, with float rExpr operands +-3.4028235E38 * 1.4E-45 = -4.7683713E-7, with float rExpr operands +-3.4028235E38 / 1.4E-45 = -Infinity, with float rExpr operands +-3.4028235E38 + 1.4E-45 = -3.4028235E38, with float exprs operands +-3.4028235E38 - 1.4E-45 = -3.4028235E38, with float exprs operands +-3.4028235E38 * 1.4E-45 = -4.7683713E-7, with float exprs operands +-3.4028235E38 / 1.4E-45 = -Infinity, with float exprs operands +-3.4028235E38 + 3.4028235E38 = 0.0, with float param operands +-3.4028235E38 - 3.4028235E38 = -Infinity, with float param operands +-3.4028235E38 * 3.4028235E38 = -Infinity, with float param operands +-3.4028235E38 / 3.4028235E38 = -1.0, with float param operands +-3.4028235E38 + 3.4028235E38 = 0.0, with float local operands +-3.4028235E38 - 3.4028235E38 = -Infinity, with float local operands +-3.4028235E38 * 3.4028235E38 = -Infinity, with float local operands +-3.4028235E38 / 3.4028235E38 = -1.0, with float local operands +-3.4028235E38 + 3.4028235E38 = 0.0, with float static operands +-3.4028235E38 - 3.4028235E38 = -Infinity, with float static operands +-3.4028235E38 * 3.4028235E38 = -Infinity, with float static operands +-3.4028235E38 / 3.4028235E38 = -1.0, with float static operands +-3.4028235E38 + 3.4028235E38 = 0.0, with float field operands +-3.4028235E38 - 3.4028235E38 = -Infinity, with float field operands +-3.4028235E38 * 3.4028235E38 = -Infinity, with float field operands +-3.4028235E38 / 3.4028235E38 = -1.0, with float field operands +-3.4028235E38 + 3.4028235E38 = 0.0, with float a[i] operands +-3.4028235E38 - 3.4028235E38 = -Infinity, with float a[i] operands +-3.4028235E38 * 3.4028235E38 = -Infinity, with float a[i] operands +-3.4028235E38 / 3.4028235E38 = -1.0, with float a[i] operands +-3.4028235E38 + 3.4028235E38 = 0.0, with float f(x) operands +-3.4028235E38 - 3.4028235E38 = -Infinity, with float f(x) operands +-3.4028235E38 * 3.4028235E38 = -Infinity, with float f(x) operands +-3.4028235E38 / 3.4028235E38 = -1.0, with float f(x) operands +-3.4028235E38 + 3.4028235E38 = 0.0, with float lExpr operands +-3.4028235E38 - 3.4028235E38 = -Infinity, with float lExpr operands +-3.4028235E38 * 3.4028235E38 = -Infinity, with float lExpr operands +-3.4028235E38 / 3.4028235E38 = -1.0, with float lExpr operands +-3.4028235E38 + 3.4028235E38 = 0.0, with float rExpr operands +-3.4028235E38 - 3.4028235E38 = -Infinity, with float rExpr operands +-3.4028235E38 * 3.4028235E38 = -Infinity, with float rExpr operands +-3.4028235E38 / 3.4028235E38 = -1.0, with float rExpr operands +-3.4028235E38 + 3.4028235E38 = 0.0, with float exprs operands +-3.4028235E38 - 3.4028235E38 = -Infinity, with float exprs operands +-3.4028235E38 * 3.4028235E38 = -Infinity, with float exprs operands +-3.4028235E38 / 3.4028235E38 = -1.0, with float exprs operands +-3.4028235E38 + -1.4E-45 = -3.4028235E38, with float param operands +-3.4028235E38 - -1.4E-45 = -3.4028235E38, with float param operands +-3.4028235E38 * -1.4E-45 = 4.7683713E-7, with float param operands +-3.4028235E38 / -1.4E-45 = Infinity, with float param operands +-3.4028235E38 + -1.4E-45 = -3.4028235E38, with float local operands +-3.4028235E38 - -1.4E-45 = -3.4028235E38, with float local operands +-3.4028235E38 * -1.4E-45 = 4.7683713E-7, with float local operands +-3.4028235E38 / -1.4E-45 = Infinity, with float local operands +-3.4028235E38 + -1.4E-45 = -3.4028235E38, with float static operands +-3.4028235E38 - -1.4E-45 = -3.4028235E38, with float static operands +-3.4028235E38 * -1.4E-45 = 4.7683713E-7, with float static operands +-3.4028235E38 / -1.4E-45 = Infinity, with float static operands +-3.4028235E38 + -1.4E-45 = -3.4028235E38, with float field operands +-3.4028235E38 - -1.4E-45 = -3.4028235E38, with float field operands +-3.4028235E38 * -1.4E-45 = 4.7683713E-7, with float field operands +-3.4028235E38 / -1.4E-45 = Infinity, with float field operands +-3.4028235E38 + -1.4E-45 = -3.4028235E38, with float a[i] operands +-3.4028235E38 - -1.4E-45 = -3.4028235E38, with float a[i] operands +-3.4028235E38 * -1.4E-45 = 4.7683713E-7, with float a[i] operands +-3.4028235E38 / -1.4E-45 = Infinity, with float a[i] operands +-3.4028235E38 + -1.4E-45 = -3.4028235E38, with float f(x) operands +-3.4028235E38 - -1.4E-45 = -3.4028235E38, with float f(x) operands +-3.4028235E38 * -1.4E-45 = 4.7683713E-7, with float f(x) operands +-3.4028235E38 / -1.4E-45 = Infinity, with float f(x) operands +-3.4028235E38 + -1.4E-45 = -3.4028235E38, with float lExpr operands +-3.4028235E38 - -1.4E-45 = -3.4028235E38, with float lExpr operands +-3.4028235E38 * -1.4E-45 = 4.7683713E-7, with float lExpr operands +-3.4028235E38 / -1.4E-45 = Infinity, with float lExpr operands +-3.4028235E38 + -1.4E-45 = -3.4028235E38, with float rExpr operands +-3.4028235E38 - -1.4E-45 = -3.4028235E38, with float rExpr operands +-3.4028235E38 * -1.4E-45 = 4.7683713E-7, with float rExpr operands +-3.4028235E38 / -1.4E-45 = Infinity, with float rExpr operands +-3.4028235E38 + -1.4E-45 = -3.4028235E38, with float exprs operands +-3.4028235E38 - -1.4E-45 = -3.4028235E38, with float exprs operands +-3.4028235E38 * -1.4E-45 = 4.7683713E-7, with float exprs operands +-3.4028235E38 / -1.4E-45 = Infinity, with float exprs operands +-3.4028235E38 + -3.4028235E38 = -Infinity, with float param operands +-3.4028235E38 - -3.4028235E38 = 0.0, with float param operands +-3.4028235E38 * -3.4028235E38 = Infinity, with float param operands +-3.4028235E38 / -3.4028235E38 = 1.0, with float param operands +-3.4028235E38 + -3.4028235E38 = -Infinity, with float local operands +-3.4028235E38 - -3.4028235E38 = 0.0, with float local operands +-3.4028235E38 * -3.4028235E38 = Infinity, with float local operands +-3.4028235E38 / -3.4028235E38 = 1.0, with float local operands +-3.4028235E38 + -3.4028235E38 = -Infinity, with float static operands +-3.4028235E38 - -3.4028235E38 = 0.0, with float static operands +-3.4028235E38 * -3.4028235E38 = Infinity, with float static operands +-3.4028235E38 / -3.4028235E38 = 1.0, with float static operands +-3.4028235E38 + -3.4028235E38 = -Infinity, with float field operands +-3.4028235E38 - -3.4028235E38 = 0.0, with float field operands +-3.4028235E38 * -3.4028235E38 = Infinity, with float field operands +-3.4028235E38 / -3.4028235E38 = 1.0, with float field operands +-3.4028235E38 + -3.4028235E38 = -Infinity, with float a[i] operands +-3.4028235E38 - -3.4028235E38 = 0.0, with float a[i] operands +-3.4028235E38 * -3.4028235E38 = Infinity, with float a[i] operands +-3.4028235E38 / -3.4028235E38 = 1.0, with float a[i] operands +-3.4028235E38 + -3.4028235E38 = -Infinity, with float f(x) operands +-3.4028235E38 - -3.4028235E38 = 0.0, with float f(x) operands +-3.4028235E38 * -3.4028235E38 = Infinity, with float f(x) operands +-3.4028235E38 / -3.4028235E38 = 1.0, with float f(x) operands +-3.4028235E38 + -3.4028235E38 = -Infinity, with float lExpr operands +-3.4028235E38 - -3.4028235E38 = 0.0, with float lExpr operands +-3.4028235E38 * -3.4028235E38 = Infinity, with float lExpr operands +-3.4028235E38 / -3.4028235E38 = 1.0, with float lExpr operands +-3.4028235E38 + -3.4028235E38 = -Infinity, with float rExpr operands +-3.4028235E38 - -3.4028235E38 = 0.0, with float rExpr operands +-3.4028235E38 * -3.4028235E38 = Infinity, with float rExpr operands +-3.4028235E38 / -3.4028235E38 = 1.0, with float rExpr operands +-3.4028235E38 + -3.4028235E38 = -Infinity, with float exprs operands +-3.4028235E38 - -3.4028235E38 = 0.0, with float exprs operands +-3.4028235E38 * -3.4028235E38 = Infinity, with float exprs operands +-3.4028235E38 / -3.4028235E38 = 1.0, with float exprs operands +-3.4028235E38 + -1.0 = -3.4028235E38, with float param operands +-3.4028235E38 - -1.0 = -3.4028235E38, with float param operands +-3.4028235E38 * -1.0 = 3.4028235E38, with float param operands +-3.4028235E38 / -1.0 = 3.4028235E38, with float param operands +-3.4028235E38 + -1.0 = -3.4028235E38, with float local operands +-3.4028235E38 - -1.0 = -3.4028235E38, with float local operands +-3.4028235E38 * -1.0 = 3.4028235E38, with float local operands +-3.4028235E38 / -1.0 = 3.4028235E38, with float local operands +-3.4028235E38 + -1.0 = -3.4028235E38, with float static operands +-3.4028235E38 - -1.0 = -3.4028235E38, with float static operands +-3.4028235E38 * -1.0 = 3.4028235E38, with float static operands +-3.4028235E38 / -1.0 = 3.4028235E38, with float static operands +-3.4028235E38 + -1.0 = -3.4028235E38, with float field operands +-3.4028235E38 - -1.0 = -3.4028235E38, with float field operands +-3.4028235E38 * -1.0 = 3.4028235E38, with float field operands +-3.4028235E38 / -1.0 = 3.4028235E38, with float field operands +-3.4028235E38 + -1.0 = -3.4028235E38, with float a[i] operands +-3.4028235E38 - -1.0 = -3.4028235E38, with float a[i] operands +-3.4028235E38 * -1.0 = 3.4028235E38, with float a[i] operands +-3.4028235E38 / -1.0 = 3.4028235E38, with float a[i] operands +-3.4028235E38 + -1.0 = -3.4028235E38, with float f(x) operands +-3.4028235E38 - -1.0 = -3.4028235E38, with float f(x) operands +-3.4028235E38 * -1.0 = 3.4028235E38, with float f(x) operands +-3.4028235E38 / -1.0 = 3.4028235E38, with float f(x) operands +-3.4028235E38 + -1.0 = -3.4028235E38, with float lExpr operands +-3.4028235E38 - -1.0 = -3.4028235E38, with float lExpr operands +-3.4028235E38 * -1.0 = 3.4028235E38, with float lExpr operands +-3.4028235E38 / -1.0 = 3.4028235E38, with float lExpr operands +-3.4028235E38 + -1.0 = -3.4028235E38, with float rExpr operands +-3.4028235E38 - -1.0 = -3.4028235E38, with float rExpr operands +-3.4028235E38 * -1.0 = 3.4028235E38, with float rExpr operands +-3.4028235E38 / -1.0 = 3.4028235E38, with float rExpr operands +-3.4028235E38 + -1.0 = -3.4028235E38, with float exprs operands +-3.4028235E38 - -1.0 = -3.4028235E38, with float exprs operands +-3.4028235E38 * -1.0 = 3.4028235E38, with float exprs operands +-3.4028235E38 / -1.0 = 3.4028235E38, with float exprs operands +-3.4028235E38 + 1.0 = -3.4028235E38, with float param operands +-3.4028235E38 - 1.0 = -3.4028235E38, with float param operands +-3.4028235E38 * 1.0 = -3.4028235E38, with float param operands +-3.4028235E38 / 1.0 = -3.4028235E38, with float param operands +-3.4028235E38 + 1.0 = -3.4028235E38, with float local operands +-3.4028235E38 - 1.0 = -3.4028235E38, with float local operands +-3.4028235E38 * 1.0 = -3.4028235E38, with float local operands +-3.4028235E38 / 1.0 = -3.4028235E38, with float local operands +-3.4028235E38 + 1.0 = -3.4028235E38, with float static operands +-3.4028235E38 - 1.0 = -3.4028235E38, with float static operands +-3.4028235E38 * 1.0 = -3.4028235E38, with float static operands +-3.4028235E38 / 1.0 = -3.4028235E38, with float static operands +-3.4028235E38 + 1.0 = -3.4028235E38, with float field operands +-3.4028235E38 - 1.0 = -3.4028235E38, with float field operands +-3.4028235E38 * 1.0 = -3.4028235E38, with float field operands +-3.4028235E38 / 1.0 = -3.4028235E38, with float field operands +-3.4028235E38 + 1.0 = -3.4028235E38, with float a[i] operands +-3.4028235E38 - 1.0 = -3.4028235E38, with float a[i] operands +-3.4028235E38 * 1.0 = -3.4028235E38, with float a[i] operands +-3.4028235E38 / 1.0 = -3.4028235E38, with float a[i] operands +-3.4028235E38 + 1.0 = -3.4028235E38, with float f(x) operands +-3.4028235E38 - 1.0 = -3.4028235E38, with float f(x) operands +-3.4028235E38 * 1.0 = -3.4028235E38, with float f(x) operands +-3.4028235E38 / 1.0 = -3.4028235E38, with float f(x) operands +-3.4028235E38 + 1.0 = -3.4028235E38, with float lExpr operands +-3.4028235E38 - 1.0 = -3.4028235E38, with float lExpr operands +-3.4028235E38 * 1.0 = -3.4028235E38, with float lExpr operands +-3.4028235E38 / 1.0 = -3.4028235E38, with float lExpr operands +-3.4028235E38 + 1.0 = -3.4028235E38, with float rExpr operands +-3.4028235E38 - 1.0 = -3.4028235E38, with float rExpr operands +-3.4028235E38 * 1.0 = -3.4028235E38, with float rExpr operands +-3.4028235E38 / 1.0 = -3.4028235E38, with float rExpr operands +-3.4028235E38 + 1.0 = -3.4028235E38, with float exprs operands +-3.4028235E38 - 1.0 = -3.4028235E38, with float exprs operands +-3.4028235E38 * 1.0 = -3.4028235E38, with float exprs operands +-3.4028235E38 / 1.0 = -3.4028235E38, with float exprs operands +-3.4028235E38 + -0.0 = -3.4028235E38, with float param operands +-3.4028235E38 - -0.0 = -3.4028235E38, with float param operands +-3.4028235E38 * -0.0 = 0.0, with float param operands +-3.4028235E38 / -0.0 = Infinity, with float param operands +-3.4028235E38 + -0.0 = -3.4028235E38, with float local operands +-3.4028235E38 - -0.0 = -3.4028235E38, with float local operands +-3.4028235E38 * -0.0 = 0.0, with float local operands +-3.4028235E38 / -0.0 = Infinity, with float local operands +-3.4028235E38 + -0.0 = -3.4028235E38, with float static operands +-3.4028235E38 - -0.0 = -3.4028235E38, with float static operands +-3.4028235E38 * -0.0 = 0.0, with float static operands +-3.4028235E38 / -0.0 = Infinity, with float static operands +-3.4028235E38 + -0.0 = -3.4028235E38, with float field operands +-3.4028235E38 - -0.0 = -3.4028235E38, with float field operands +-3.4028235E38 * -0.0 = 0.0, with float field operands +-3.4028235E38 / -0.0 = Infinity, with float field operands +-3.4028235E38 + -0.0 = -3.4028235E38, with float a[i] operands +-3.4028235E38 - -0.0 = -3.4028235E38, with float a[i] operands +-3.4028235E38 * -0.0 = 0.0, with float a[i] operands +-3.4028235E38 / -0.0 = Infinity, with float a[i] operands +-3.4028235E38 + -0.0 = -3.4028235E38, with float f(x) operands +-3.4028235E38 - -0.0 = -3.4028235E38, with float f(x) operands +-3.4028235E38 * -0.0 = 0.0, with float f(x) operands +-3.4028235E38 / -0.0 = Infinity, with float f(x) operands +-3.4028235E38 + -0.0 = -3.4028235E38, with float lExpr operands +-3.4028235E38 - -0.0 = -3.4028235E38, with float lExpr operands +-3.4028235E38 * -0.0 = 0.0, with float lExpr operands +-3.4028235E38 / -0.0 = Infinity, with float lExpr operands +-3.4028235E38 + 0.0 = -3.4028235E38, with float rExpr operands +-3.4028235E38 - 0.0 = -3.4028235E38, with float rExpr operands +-3.4028235E38 * 0.0 = -0.0, with float rExpr operands +-3.4028235E38 / 0.0 = -Infinity, with float rExpr operands +-3.4028235E38 + 0.0 = -3.4028235E38, with float exprs operands +-3.4028235E38 - 0.0 = -3.4028235E38, with float exprs operands +-3.4028235E38 * 0.0 = -0.0, with float exprs operands +-3.4028235E38 / 0.0 = -Infinity, with float exprs operands +-3.4028235E38 + 0.0 = -3.4028235E38, with float param operands +-3.4028235E38 - 0.0 = -3.4028235E38, with float param operands +-3.4028235E38 * 0.0 = -0.0, with float param operands +-3.4028235E38 / 0.0 = -Infinity, with float param operands +-3.4028235E38 + 0.0 = -3.4028235E38, with float local operands +-3.4028235E38 - 0.0 = -3.4028235E38, with float local operands +-3.4028235E38 * 0.0 = -0.0, with float local operands +-3.4028235E38 / 0.0 = -Infinity, with float local operands +-3.4028235E38 + 0.0 = -3.4028235E38, with float static operands +-3.4028235E38 - 0.0 = -3.4028235E38, with float static operands +-3.4028235E38 * 0.0 = -0.0, with float static operands +-3.4028235E38 / 0.0 = -Infinity, with float static operands +-3.4028235E38 + 0.0 = -3.4028235E38, with float field operands +-3.4028235E38 - 0.0 = -3.4028235E38, with float field operands +-3.4028235E38 * 0.0 = -0.0, with float field operands +-3.4028235E38 / 0.0 = -Infinity, with float field operands +-3.4028235E38 + 0.0 = -3.4028235E38, with float a[i] operands +-3.4028235E38 - 0.0 = -3.4028235E38, with float a[i] operands +-3.4028235E38 * 0.0 = -0.0, with float a[i] operands +-3.4028235E38 / 0.0 = -Infinity, with float a[i] operands +-3.4028235E38 + 0.0 = -3.4028235E38, with float f(x) operands +-3.4028235E38 - 0.0 = -3.4028235E38, with float f(x) operands +-3.4028235E38 * 0.0 = -0.0, with float f(x) operands +-3.4028235E38 / 0.0 = -Infinity, with float f(x) operands +-3.4028235E38 + 0.0 = -3.4028235E38, with float lExpr operands +-3.4028235E38 - 0.0 = -3.4028235E38, with float lExpr operands +-3.4028235E38 * 0.0 = -0.0, with float lExpr operands +-3.4028235E38 / 0.0 = -Infinity, with float lExpr operands +-3.4028235E38 + 0.0 = -3.4028235E38, with float rExpr operands +-3.4028235E38 - 0.0 = -3.4028235E38, with float rExpr operands +-3.4028235E38 * 0.0 = -0.0, with float rExpr operands +-3.4028235E38 / 0.0 = -Infinity, with float rExpr operands +-3.4028235E38 + 0.0 = -3.4028235E38, with float exprs operands +-3.4028235E38 - 0.0 = -3.4028235E38, with float exprs operands +-3.4028235E38 * 0.0 = -0.0, with float exprs operands +-3.4028235E38 / 0.0 = -Infinity, with float exprs operands +-3.4028235E38 + -Infinity = -Infinity, with float param operands +-3.4028235E38 - -Infinity = Infinity, with float param operands +-3.4028235E38 * -Infinity = Infinity, with float param operands +-3.4028235E38 / -Infinity = 0.0, with float param operands +-3.4028235E38 + -Infinity = -Infinity, with float local operands +-3.4028235E38 - -Infinity = Infinity, with float local operands +-3.4028235E38 * -Infinity = Infinity, with float local operands +-3.4028235E38 / -Infinity = 0.0, with float local operands +-3.4028235E38 + -Infinity = -Infinity, with float static operands +-3.4028235E38 - -Infinity = Infinity, with float static operands +-3.4028235E38 * -Infinity = Infinity, with float static operands +-3.4028235E38 / -Infinity = 0.0, with float static operands +-3.4028235E38 + -Infinity = -Infinity, with float field operands +-3.4028235E38 - -Infinity = Infinity, with float field operands +-3.4028235E38 * -Infinity = Infinity, with float field operands +-3.4028235E38 / -Infinity = 0.0, with float field operands +-3.4028235E38 + -Infinity = -Infinity, with float a[i] operands +-3.4028235E38 - -Infinity = Infinity, with float a[i] operands +-3.4028235E38 * -Infinity = Infinity, with float a[i] operands +-3.4028235E38 / -Infinity = 0.0, with float a[i] operands +-3.4028235E38 + -Infinity = -Infinity, with float f(x) operands +-3.4028235E38 - -Infinity = Infinity, with float f(x) operands +-3.4028235E38 * -Infinity = Infinity, with float f(x) operands +-3.4028235E38 / -Infinity = 0.0, with float f(x) operands +-3.4028235E38 + -Infinity = -Infinity, with float lExpr operands +-3.4028235E38 - -Infinity = Infinity, with float lExpr operands +-3.4028235E38 * -Infinity = Infinity, with float lExpr operands +-3.4028235E38 / -Infinity = 0.0, with float lExpr operands +-3.4028235E38 + -Infinity = -Infinity, with float rExpr operands +-3.4028235E38 - -Infinity = Infinity, with float rExpr operands +-3.4028235E38 * -Infinity = Infinity, with float rExpr operands +-3.4028235E38 / -Infinity = 0.0, with float rExpr operands +-3.4028235E38 + -Infinity = -Infinity, with float exprs operands +-3.4028235E38 - -Infinity = Infinity, with float exprs operands +-3.4028235E38 * -Infinity = Infinity, with float exprs operands +-3.4028235E38 / -Infinity = 0.0, with float exprs operands +-3.4028235E38 + Infinity = Infinity, with float param operands +-3.4028235E38 - Infinity = -Infinity, with float param operands +-3.4028235E38 * Infinity = -Infinity, with float param operands +-3.4028235E38 / Infinity = -0.0, with float param operands +-3.4028235E38 + Infinity = Infinity, with float local operands +-3.4028235E38 - Infinity = -Infinity, with float local operands +-3.4028235E38 * Infinity = -Infinity, with float local operands +-3.4028235E38 / Infinity = -0.0, with float local operands +-3.4028235E38 + Infinity = Infinity, with float static operands +-3.4028235E38 - Infinity = -Infinity, with float static operands +-3.4028235E38 * Infinity = -Infinity, with float static operands +-3.4028235E38 / Infinity = -0.0, with float static operands +-3.4028235E38 + Infinity = Infinity, with float field operands +-3.4028235E38 - Infinity = -Infinity, with float field operands +-3.4028235E38 * Infinity = -Infinity, with float field operands +-3.4028235E38 / Infinity = -0.0, with float field operands +-3.4028235E38 + Infinity = Infinity, with float a[i] operands +-3.4028235E38 - Infinity = -Infinity, with float a[i] operands +-3.4028235E38 * Infinity = -Infinity, with float a[i] operands +-3.4028235E38 / Infinity = -0.0, with float a[i] operands +-3.4028235E38 + Infinity = Infinity, with float f(x) operands +-3.4028235E38 - Infinity = -Infinity, with float f(x) operands +-3.4028235E38 * Infinity = -Infinity, with float f(x) operands +-3.4028235E38 / Infinity = -0.0, with float f(x) operands +-3.4028235E38 + Infinity = Infinity, with float lExpr operands +-3.4028235E38 - Infinity = -Infinity, with float lExpr operands +-3.4028235E38 * Infinity = -Infinity, with float lExpr operands +-3.4028235E38 / Infinity = -0.0, with float lExpr operands +-3.4028235E38 + Infinity = Infinity, with float rExpr operands +-3.4028235E38 - Infinity = -Infinity, with float rExpr operands +-3.4028235E38 * Infinity = -Infinity, with float rExpr operands +-3.4028235E38 / Infinity = -0.0, with float rExpr operands +-3.4028235E38 + Infinity = Infinity, with float exprs operands +-3.4028235E38 - Infinity = -Infinity, with float exprs operands +-3.4028235E38 * Infinity = -Infinity, with float exprs operands +-3.4028235E38 / Infinity = -0.0, with float exprs operands +-3.4028235E38 + NaN = NaN, with float param operands +-3.4028235E38 - NaN = NaN, with float param operands +-3.4028235E38 * NaN = NaN, with float param operands +-3.4028235E38 / NaN = NaN, with float param operands +-3.4028235E38 + NaN = NaN, with float local operands +-3.4028235E38 - NaN = NaN, with float local operands +-3.4028235E38 * NaN = NaN, with float local operands +-3.4028235E38 / NaN = NaN, with float local operands +-3.4028235E38 + NaN = NaN, with float static operands +-3.4028235E38 - NaN = NaN, with float static operands +-3.4028235E38 * NaN = NaN, with float static operands +-3.4028235E38 / NaN = NaN, with float static operands +-3.4028235E38 + NaN = NaN, with float field operands +-3.4028235E38 - NaN = NaN, with float field operands +-3.4028235E38 * NaN = NaN, with float field operands +-3.4028235E38 / NaN = NaN, with float field operands +-3.4028235E38 + NaN = NaN, with float a[i] operands +-3.4028235E38 - NaN = NaN, with float a[i] operands +-3.4028235E38 * NaN = NaN, with float a[i] operands +-3.4028235E38 / NaN = NaN, with float a[i] operands +-3.4028235E38 + NaN = NaN, with float f(x) operands +-3.4028235E38 - NaN = NaN, with float f(x) operands +-3.4028235E38 * NaN = NaN, with float f(x) operands +-3.4028235E38 / NaN = NaN, with float f(x) operands +-3.4028235E38 + NaN = NaN, with float lExpr operands +-3.4028235E38 - NaN = NaN, with float lExpr operands +-3.4028235E38 * NaN = NaN, with float lExpr operands +-3.4028235E38 / NaN = NaN, with float lExpr operands +-3.4028235E38 + NaN = NaN, with float rExpr operands +-3.4028235E38 - NaN = NaN, with float rExpr operands +-3.4028235E38 * NaN = NaN, with float rExpr operands +-3.4028235E38 / NaN = NaN, with float rExpr operands +-3.4028235E38 + NaN = NaN, with float exprs operands +-3.4028235E38 - NaN = NaN, with float exprs operands +-3.4028235E38 * NaN = NaN, with float exprs operands +-3.4028235E38 / NaN = NaN, with float exprs operands +-1.0 + 1.4E-45 = -1.0, with float param operands +-1.0 - 1.4E-45 = -1.0, with float param operands +-1.0 * 1.4E-45 = -1.4E-45, with float param operands +-1.0 / 1.4E-45 = -Infinity, with float param operands +-1.0 + 1.4E-45 = -1.0, with float local operands +-1.0 - 1.4E-45 = -1.0, with float local operands +-1.0 * 1.4E-45 = -1.4E-45, with float local operands +-1.0 / 1.4E-45 = -Infinity, with float local operands +-1.0 + 1.4E-45 = -1.0, with float static operands +-1.0 - 1.4E-45 = -1.0, with float static operands +-1.0 * 1.4E-45 = -1.4E-45, with float static operands +-1.0 / 1.4E-45 = -Infinity, with float static operands +-1.0 + 1.4E-45 = -1.0, with float field operands +-1.0 - 1.4E-45 = -1.0, with float field operands +-1.0 * 1.4E-45 = -1.4E-45, with float field operands +-1.0 / 1.4E-45 = -Infinity, with float field operands +-1.0 + 1.4E-45 = -1.0, with float a[i] operands +-1.0 - 1.4E-45 = -1.0, with float a[i] operands +-1.0 * 1.4E-45 = -1.4E-45, with float a[i] operands +-1.0 / 1.4E-45 = -Infinity, with float a[i] operands +-1.0 + 1.4E-45 = -1.0, with float f(x) operands +-1.0 - 1.4E-45 = -1.0, with float f(x) operands +-1.0 * 1.4E-45 = -1.4E-45, with float f(x) operands +-1.0 / 1.4E-45 = -Infinity, with float f(x) operands +-1.0 + 1.4E-45 = -1.0, with float lExpr operands +-1.0 - 1.4E-45 = -1.0, with float lExpr operands +-1.0 * 1.4E-45 = -1.4E-45, with float lExpr operands +-1.0 / 1.4E-45 = -Infinity, with float lExpr operands +-1.0 + 1.4E-45 = -1.0, with float rExpr operands +-1.0 - 1.4E-45 = -1.0, with float rExpr operands +-1.0 * 1.4E-45 = -1.4E-45, with float rExpr operands +-1.0 / 1.4E-45 = -Infinity, with float rExpr operands +-1.0 + 1.4E-45 = -1.0, with float exprs operands +-1.0 - 1.4E-45 = -1.0, with float exprs operands +-1.0 * 1.4E-45 = -1.4E-45, with float exprs operands +-1.0 / 1.4E-45 = -Infinity, with float exprs operands +-1.0 + 3.4028235E38 = 3.4028235E38, with float param operands +-1.0 - 3.4028235E38 = -3.4028235E38, with float param operands +-1.0 * 3.4028235E38 = -3.4028235E38, with float param operands +-1.0 / 3.4028235E38 = -2.938736E-39, with float param operands +-1.0 + 3.4028235E38 = 3.4028235E38, with float local operands +-1.0 - 3.4028235E38 = -3.4028235E38, with float local operands +-1.0 * 3.4028235E38 = -3.4028235E38, with float local operands +-1.0 / 3.4028235E38 = -2.938736E-39, with float local operands +-1.0 + 3.4028235E38 = 3.4028235E38, with float static operands +-1.0 - 3.4028235E38 = -3.4028235E38, with float static operands +-1.0 * 3.4028235E38 = -3.4028235E38, with float static operands +-1.0 / 3.4028235E38 = -2.938736E-39, with float static operands +-1.0 + 3.4028235E38 = 3.4028235E38, with float field operands +-1.0 - 3.4028235E38 = -3.4028235E38, with float field operands +-1.0 * 3.4028235E38 = -3.4028235E38, with float field operands +-1.0 / 3.4028235E38 = -2.938736E-39, with float field operands +-1.0 + 3.4028235E38 = 3.4028235E38, with float a[i] operands +-1.0 - 3.4028235E38 = -3.4028235E38, with float a[i] operands +-1.0 * 3.4028235E38 = -3.4028235E38, with float a[i] operands +-1.0 / 3.4028235E38 = -2.938736E-39, with float a[i] operands +-1.0 + 3.4028235E38 = 3.4028235E38, with float f(x) operands +-1.0 - 3.4028235E38 = -3.4028235E38, with float f(x) operands +-1.0 * 3.4028235E38 = -3.4028235E38, with float f(x) operands +-1.0 / 3.4028235E38 = -2.938736E-39, with float f(x) operands +-1.0 + 3.4028235E38 = 3.4028235E38, with float lExpr operands +-1.0 - 3.4028235E38 = -3.4028235E38, with float lExpr operands +-1.0 * 3.4028235E38 = -3.4028235E38, with float lExpr operands +-1.0 / 3.4028235E38 = -2.938736E-39, with float lExpr operands +-1.0 + 3.4028235E38 = 3.4028235E38, with float rExpr operands +-1.0 - 3.4028235E38 = -3.4028235E38, with float rExpr operands +-1.0 * 3.4028235E38 = -3.4028235E38, with float rExpr operands +-1.0 / 3.4028235E38 = -2.938736E-39, with float rExpr operands +-1.0 + 3.4028235E38 = 3.4028235E38, with float exprs operands +-1.0 - 3.4028235E38 = -3.4028235E38, with float exprs operands +-1.0 * 3.4028235E38 = -3.4028235E38, with float exprs operands +-1.0 / 3.4028235E38 = -2.938736E-39, with float exprs operands +-1.0 + -1.4E-45 = -1.0, with float param operands +-1.0 - -1.4E-45 = -1.0, with float param operands +-1.0 * -1.4E-45 = 1.4E-45, with float param operands +-1.0 / -1.4E-45 = Infinity, with float param operands +-1.0 + -1.4E-45 = -1.0, with float local operands +-1.0 - -1.4E-45 = -1.0, with float local operands +-1.0 * -1.4E-45 = 1.4E-45, with float local operands +-1.0 / -1.4E-45 = Infinity, with float local operands +-1.0 + -1.4E-45 = -1.0, with float static operands +-1.0 - -1.4E-45 = -1.0, with float static operands +-1.0 * -1.4E-45 = 1.4E-45, with float static operands +-1.0 / -1.4E-45 = Infinity, with float static operands +-1.0 + -1.4E-45 = -1.0, with float field operands +-1.0 - -1.4E-45 = -1.0, with float field operands +-1.0 * -1.4E-45 = 1.4E-45, with float field operands +-1.0 / -1.4E-45 = Infinity, with float field operands +-1.0 + -1.4E-45 = -1.0, with float a[i] operands +-1.0 - -1.4E-45 = -1.0, with float a[i] operands +-1.0 * -1.4E-45 = 1.4E-45, with float a[i] operands +-1.0 / -1.4E-45 = Infinity, with float a[i] operands +-1.0 + -1.4E-45 = -1.0, with float f(x) operands +-1.0 - -1.4E-45 = -1.0, with float f(x) operands +-1.0 * -1.4E-45 = 1.4E-45, with float f(x) operands +-1.0 / -1.4E-45 = Infinity, with float f(x) operands +-1.0 + -1.4E-45 = -1.0, with float lExpr operands +-1.0 - -1.4E-45 = -1.0, with float lExpr operands +-1.0 * -1.4E-45 = 1.4E-45, with float lExpr operands +-1.0 / -1.4E-45 = Infinity, with float lExpr operands +-1.0 + -1.4E-45 = -1.0, with float rExpr operands +-1.0 - -1.4E-45 = -1.0, with float rExpr operands +-1.0 * -1.4E-45 = 1.4E-45, with float rExpr operands +-1.0 / -1.4E-45 = Infinity, with float rExpr operands +-1.0 + -1.4E-45 = -1.0, with float exprs operands +-1.0 - -1.4E-45 = -1.0, with float exprs operands +-1.0 * -1.4E-45 = 1.4E-45, with float exprs operands +-1.0 / -1.4E-45 = Infinity, with float exprs operands +-1.0 + -3.4028235E38 = -3.4028235E38, with float param operands +-1.0 - -3.4028235E38 = 3.4028235E38, with float param operands +-1.0 * -3.4028235E38 = 3.4028235E38, with float param operands +-1.0 / -3.4028235E38 = 2.938736E-39, with float param operands +-1.0 + -3.4028235E38 = -3.4028235E38, with float local operands +-1.0 - -3.4028235E38 = 3.4028235E38, with float local operands +-1.0 * -3.4028235E38 = 3.4028235E38, with float local operands +-1.0 / -3.4028235E38 = 2.938736E-39, with float local operands +-1.0 + -3.4028235E38 = -3.4028235E38, with float static operands +-1.0 - -3.4028235E38 = 3.4028235E38, with float static operands +-1.0 * -3.4028235E38 = 3.4028235E38, with float static operands +-1.0 / -3.4028235E38 = 2.938736E-39, with float static operands +-1.0 + -3.4028235E38 = -3.4028235E38, with float field operands +-1.0 - -3.4028235E38 = 3.4028235E38, with float field operands +-1.0 * -3.4028235E38 = 3.4028235E38, with float field operands +-1.0 / -3.4028235E38 = 2.938736E-39, with float field operands +-1.0 + -3.4028235E38 = -3.4028235E38, with float a[i] operands +-1.0 - -3.4028235E38 = 3.4028235E38, with float a[i] operands +-1.0 * -3.4028235E38 = 3.4028235E38, with float a[i] operands +-1.0 / -3.4028235E38 = 2.938736E-39, with float a[i] operands +-1.0 + -3.4028235E38 = -3.4028235E38, with float f(x) operands +-1.0 - -3.4028235E38 = 3.4028235E38, with float f(x) operands +-1.0 * -3.4028235E38 = 3.4028235E38, with float f(x) operands +-1.0 / -3.4028235E38 = 2.938736E-39, with float f(x) operands +-1.0 + -3.4028235E38 = -3.4028235E38, with float lExpr operands +-1.0 - -3.4028235E38 = 3.4028235E38, with float lExpr operands +-1.0 * -3.4028235E38 = 3.4028235E38, with float lExpr operands +-1.0 / -3.4028235E38 = 2.938736E-39, with float lExpr operands +-1.0 + -3.4028235E38 = -3.4028235E38, with float rExpr operands +-1.0 - -3.4028235E38 = 3.4028235E38, with float rExpr operands +-1.0 * -3.4028235E38 = 3.4028235E38, with float rExpr operands +-1.0 / -3.4028235E38 = 2.938736E-39, with float rExpr operands +-1.0 + -3.4028235E38 = -3.4028235E38, with float exprs operands +-1.0 - -3.4028235E38 = 3.4028235E38, with float exprs operands +-1.0 * -3.4028235E38 = 3.4028235E38, with float exprs operands +-1.0 / -3.4028235E38 = 2.938736E-39, with float exprs operands +-1.0 + -1.0 = -2.0, with float param operands +-1.0 - -1.0 = 0.0, with float param operands +-1.0 * -1.0 = 1.0, with float param operands +-1.0 / -1.0 = 1.0, with float param operands +-1.0 + -1.0 = -2.0, with float local operands +-1.0 - -1.0 = 0.0, with float local operands +-1.0 * -1.0 = 1.0, with float local operands +-1.0 / -1.0 = 1.0, with float local operands +-1.0 + -1.0 = -2.0, with float static operands +-1.0 - -1.0 = 0.0, with float static operands +-1.0 * -1.0 = 1.0, with float static operands +-1.0 / -1.0 = 1.0, with float static operands +-1.0 + -1.0 = -2.0, with float field operands +-1.0 - -1.0 = 0.0, with float field operands +-1.0 * -1.0 = 1.0, with float field operands +-1.0 / -1.0 = 1.0, with float field operands +-1.0 + -1.0 = -2.0, with float a[i] operands +-1.0 - -1.0 = 0.0, with float a[i] operands +-1.0 * -1.0 = 1.0, with float a[i] operands +-1.0 / -1.0 = 1.0, with float a[i] operands +-1.0 + -1.0 = -2.0, with float f(x) operands +-1.0 - -1.0 = 0.0, with float f(x) operands +-1.0 * -1.0 = 1.0, with float f(x) operands +-1.0 / -1.0 = 1.0, with float f(x) operands +-1.0 + -1.0 = -2.0, with float lExpr operands +-1.0 - -1.0 = 0.0, with float lExpr operands +-1.0 * -1.0 = 1.0, with float lExpr operands +-1.0 / -1.0 = 1.0, with float lExpr operands +-1.0 + -1.0 = -2.0, with float rExpr operands +-1.0 - -1.0 = 0.0, with float rExpr operands +-1.0 * -1.0 = 1.0, with float rExpr operands +-1.0 / -1.0 = 1.0, with float rExpr operands +-1.0 + -1.0 = -2.0, with float exprs operands +-1.0 - -1.0 = 0.0, with float exprs operands +-1.0 * -1.0 = 1.0, with float exprs operands +-1.0 / -1.0 = 1.0, with float exprs operands +-1.0 + 1.0 = 0.0, with float param operands +-1.0 - 1.0 = -2.0, with float param operands +-1.0 * 1.0 = -1.0, with float param operands +-1.0 / 1.0 = -1.0, with float param operands +-1.0 + 1.0 = 0.0, with float local operands +-1.0 - 1.0 = -2.0, with float local operands +-1.0 * 1.0 = -1.0, with float local operands +-1.0 / 1.0 = -1.0, with float local operands +-1.0 + 1.0 = 0.0, with float static operands +-1.0 - 1.0 = -2.0, with float static operands +-1.0 * 1.0 = -1.0, with float static operands +-1.0 / 1.0 = -1.0, with float static operands +-1.0 + 1.0 = 0.0, with float field operands +-1.0 - 1.0 = -2.0, with float field operands +-1.0 * 1.0 = -1.0, with float field operands +-1.0 / 1.0 = -1.0, with float field operands +-1.0 + 1.0 = 0.0, with float a[i] operands +-1.0 - 1.0 = -2.0, with float a[i] operands +-1.0 * 1.0 = -1.0, with float a[i] operands +-1.0 / 1.0 = -1.0, with float a[i] operands +-1.0 + 1.0 = 0.0, with float f(x) operands +-1.0 - 1.0 = -2.0, with float f(x) operands +-1.0 * 1.0 = -1.0, with float f(x) operands +-1.0 / 1.0 = -1.0, with float f(x) operands +-1.0 + 1.0 = 0.0, with float lExpr operands +-1.0 - 1.0 = -2.0, with float lExpr operands +-1.0 * 1.0 = -1.0, with float lExpr operands +-1.0 / 1.0 = -1.0, with float lExpr operands +-1.0 + 1.0 = 0.0, with float rExpr operands +-1.0 - 1.0 = -2.0, with float rExpr operands +-1.0 * 1.0 = -1.0, with float rExpr operands +-1.0 / 1.0 = -1.0, with float rExpr operands +-1.0 + 1.0 = 0.0, with float exprs operands +-1.0 - 1.0 = -2.0, with float exprs operands +-1.0 * 1.0 = -1.0, with float exprs operands +-1.0 / 1.0 = -1.0, with float exprs operands +-1.0 + -0.0 = -1.0, with float param operands +-1.0 - -0.0 = -1.0, with float param operands +-1.0 * -0.0 = 0.0, with float param operands +-1.0 / -0.0 = Infinity, with float param operands +-1.0 + -0.0 = -1.0, with float local operands +-1.0 - -0.0 = -1.0, with float local operands +-1.0 * -0.0 = 0.0, with float local operands +-1.0 / -0.0 = Infinity, with float local operands +-1.0 + -0.0 = -1.0, with float static operands +-1.0 - -0.0 = -1.0, with float static operands +-1.0 * -0.0 = 0.0, with float static operands +-1.0 / -0.0 = Infinity, with float static operands +-1.0 + -0.0 = -1.0, with float field operands +-1.0 - -0.0 = -1.0, with float field operands +-1.0 * -0.0 = 0.0, with float field operands +-1.0 / -0.0 = Infinity, with float field operands +-1.0 + -0.0 = -1.0, with float a[i] operands +-1.0 - -0.0 = -1.0, with float a[i] operands +-1.0 * -0.0 = 0.0, with float a[i] operands +-1.0 / -0.0 = Infinity, with float a[i] operands +-1.0 + -0.0 = -1.0, with float f(x) operands +-1.0 - -0.0 = -1.0, with float f(x) operands +-1.0 * -0.0 = 0.0, with float f(x) operands +-1.0 / -0.0 = Infinity, with float f(x) operands +-1.0 + -0.0 = -1.0, with float lExpr operands +-1.0 - -0.0 = -1.0, with float lExpr operands +-1.0 * -0.0 = 0.0, with float lExpr operands +-1.0 / -0.0 = Infinity, with float lExpr operands +-1.0 + 0.0 = -1.0, with float rExpr operands +-1.0 - 0.0 = -1.0, with float rExpr operands +-1.0 * 0.0 = -0.0, with float rExpr operands +-1.0 / 0.0 = -Infinity, with float rExpr operands +-1.0 + 0.0 = -1.0, with float exprs operands +-1.0 - 0.0 = -1.0, with float exprs operands +-1.0 * 0.0 = -0.0, with float exprs operands +-1.0 / 0.0 = -Infinity, with float exprs operands +-1.0 + 0.0 = -1.0, with float param operands +-1.0 - 0.0 = -1.0, with float param operands +-1.0 * 0.0 = -0.0, with float param operands +-1.0 / 0.0 = -Infinity, with float param operands +-1.0 + 0.0 = -1.0, with float local operands +-1.0 - 0.0 = -1.0, with float local operands +-1.0 * 0.0 = -0.0, with float local operands +-1.0 / 0.0 = -Infinity, with float local operands +-1.0 + 0.0 = -1.0, with float static operands +-1.0 - 0.0 = -1.0, with float static operands +-1.0 * 0.0 = -0.0, with float static operands +-1.0 / 0.0 = -Infinity, with float static operands +-1.0 + 0.0 = -1.0, with float field operands +-1.0 - 0.0 = -1.0, with float field operands +-1.0 * 0.0 = -0.0, with float field operands +-1.0 / 0.0 = -Infinity, with float field operands +-1.0 + 0.0 = -1.0, with float a[i] operands +-1.0 - 0.0 = -1.0, with float a[i] operands +-1.0 * 0.0 = -0.0, with float a[i] operands +-1.0 / 0.0 = -Infinity, with float a[i] operands +-1.0 + 0.0 = -1.0, with float f(x) operands +-1.0 - 0.0 = -1.0, with float f(x) operands +-1.0 * 0.0 = -0.0, with float f(x) operands +-1.0 / 0.0 = -Infinity, with float f(x) operands +-1.0 + 0.0 = -1.0, with float lExpr operands +-1.0 - 0.0 = -1.0, with float lExpr operands +-1.0 * 0.0 = -0.0, with float lExpr operands +-1.0 / 0.0 = -Infinity, with float lExpr operands +-1.0 + 0.0 = -1.0, with float rExpr operands +-1.0 - 0.0 = -1.0, with float rExpr operands +-1.0 * 0.0 = -0.0, with float rExpr operands +-1.0 / 0.0 = -Infinity, with float rExpr operands +-1.0 + 0.0 = -1.0, with float exprs operands +-1.0 - 0.0 = -1.0, with float exprs operands +-1.0 * 0.0 = -0.0, with float exprs operands +-1.0 / 0.0 = -Infinity, with float exprs operands +-1.0 + -Infinity = -Infinity, with float param operands +-1.0 - -Infinity = Infinity, with float param operands +-1.0 * -Infinity = Infinity, with float param operands +-1.0 / -Infinity = 0.0, with float param operands +-1.0 + -Infinity = -Infinity, with float local operands +-1.0 - -Infinity = Infinity, with float local operands +-1.0 * -Infinity = Infinity, with float local operands +-1.0 / -Infinity = 0.0, with float local operands +-1.0 + -Infinity = -Infinity, with float static operands +-1.0 - -Infinity = Infinity, with float static operands +-1.0 * -Infinity = Infinity, with float static operands +-1.0 / -Infinity = 0.0, with float static operands +-1.0 + -Infinity = -Infinity, with float field operands +-1.0 - -Infinity = Infinity, with float field operands +-1.0 * -Infinity = Infinity, with float field operands +-1.0 / -Infinity = 0.0, with float field operands +-1.0 + -Infinity = -Infinity, with float a[i] operands +-1.0 - -Infinity = Infinity, with float a[i] operands +-1.0 * -Infinity = Infinity, with float a[i] operands +-1.0 / -Infinity = 0.0, with float a[i] operands +-1.0 + -Infinity = -Infinity, with float f(x) operands +-1.0 - -Infinity = Infinity, with float f(x) operands +-1.0 * -Infinity = Infinity, with float f(x) operands +-1.0 / -Infinity = 0.0, with float f(x) operands +-1.0 + -Infinity = -Infinity, with float lExpr operands +-1.0 - -Infinity = Infinity, with float lExpr operands +-1.0 * -Infinity = Infinity, with float lExpr operands +-1.0 / -Infinity = 0.0, with float lExpr operands +-1.0 + -Infinity = -Infinity, with float rExpr operands +-1.0 - -Infinity = Infinity, with float rExpr operands +-1.0 * -Infinity = Infinity, with float rExpr operands +-1.0 / -Infinity = 0.0, with float rExpr operands +-1.0 + -Infinity = -Infinity, with float exprs operands +-1.0 - -Infinity = Infinity, with float exprs operands +-1.0 * -Infinity = Infinity, with float exprs operands +-1.0 / -Infinity = 0.0, with float exprs operands +-1.0 + Infinity = Infinity, with float param operands +-1.0 - Infinity = -Infinity, with float param operands +-1.0 * Infinity = -Infinity, with float param operands +-1.0 / Infinity = -0.0, with float param operands +-1.0 + Infinity = Infinity, with float local operands +-1.0 - Infinity = -Infinity, with float local operands +-1.0 * Infinity = -Infinity, with float local operands +-1.0 / Infinity = -0.0, with float local operands +-1.0 + Infinity = Infinity, with float static operands +-1.0 - Infinity = -Infinity, with float static operands +-1.0 * Infinity = -Infinity, with float static operands +-1.0 / Infinity = -0.0, with float static operands +-1.0 + Infinity = Infinity, with float field operands +-1.0 - Infinity = -Infinity, with float field operands +-1.0 * Infinity = -Infinity, with float field operands +-1.0 / Infinity = -0.0, with float field operands +-1.0 + Infinity = Infinity, with float a[i] operands +-1.0 - Infinity = -Infinity, with float a[i] operands +-1.0 * Infinity = -Infinity, with float a[i] operands +-1.0 / Infinity = -0.0, with float a[i] operands +-1.0 + Infinity = Infinity, with float f(x) operands +-1.0 - Infinity = -Infinity, with float f(x) operands +-1.0 * Infinity = -Infinity, with float f(x) operands +-1.0 / Infinity = -0.0, with float f(x) operands +-1.0 + Infinity = Infinity, with float lExpr operands +-1.0 - Infinity = -Infinity, with float lExpr operands +-1.0 * Infinity = -Infinity, with float lExpr operands +-1.0 / Infinity = -0.0, with float lExpr operands +-1.0 + Infinity = Infinity, with float rExpr operands +-1.0 - Infinity = -Infinity, with float rExpr operands +-1.0 * Infinity = -Infinity, with float rExpr operands +-1.0 / Infinity = -0.0, with float rExpr operands +-1.0 + Infinity = Infinity, with float exprs operands +-1.0 - Infinity = -Infinity, with float exprs operands +-1.0 * Infinity = -Infinity, with float exprs operands +-1.0 / Infinity = -0.0, with float exprs operands +-1.0 + NaN = NaN, with float param operands +-1.0 - NaN = NaN, with float param operands +-1.0 * NaN = NaN, with float param operands +-1.0 / NaN = NaN, with float param operands +-1.0 + NaN = NaN, with float local operands +-1.0 - NaN = NaN, with float local operands +-1.0 * NaN = NaN, with float local operands +-1.0 / NaN = NaN, with float local operands +-1.0 + NaN = NaN, with float static operands +-1.0 - NaN = NaN, with float static operands +-1.0 * NaN = NaN, with float static operands +-1.0 / NaN = NaN, with float static operands +-1.0 + NaN = NaN, with float field operands +-1.0 - NaN = NaN, with float field operands +-1.0 * NaN = NaN, with float field operands +-1.0 / NaN = NaN, with float field operands +-1.0 + NaN = NaN, with float a[i] operands +-1.0 - NaN = NaN, with float a[i] operands +-1.0 * NaN = NaN, with float a[i] operands +-1.0 / NaN = NaN, with float a[i] operands +-1.0 + NaN = NaN, with float f(x) operands +-1.0 - NaN = NaN, with float f(x) operands +-1.0 * NaN = NaN, with float f(x) operands +-1.0 / NaN = NaN, with float f(x) operands +-1.0 + NaN = NaN, with float lExpr operands +-1.0 - NaN = NaN, with float lExpr operands +-1.0 * NaN = NaN, with float lExpr operands +-1.0 / NaN = NaN, with float lExpr operands +-1.0 + NaN = NaN, with float rExpr operands +-1.0 - NaN = NaN, with float rExpr operands +-1.0 * NaN = NaN, with float rExpr operands +-1.0 / NaN = NaN, with float rExpr operands +-1.0 + NaN = NaN, with float exprs operands +-1.0 - NaN = NaN, with float exprs operands +-1.0 * NaN = NaN, with float exprs operands +-1.0 / NaN = NaN, with float exprs operands +1.0 + 1.4E-45 = 1.0, with float param operands +1.0 - 1.4E-45 = 1.0, with float param operands +1.0 * 1.4E-45 = 1.4E-45, with float param operands +1.0 / 1.4E-45 = Infinity, with float param operands +1.0 + 1.4E-45 = 1.0, with float local operands +1.0 - 1.4E-45 = 1.0, with float local operands +1.0 * 1.4E-45 = 1.4E-45, with float local operands +1.0 / 1.4E-45 = Infinity, with float local operands +1.0 + 1.4E-45 = 1.0, with float static operands +1.0 - 1.4E-45 = 1.0, with float static operands +1.0 * 1.4E-45 = 1.4E-45, with float static operands +1.0 / 1.4E-45 = Infinity, with float static operands +1.0 + 1.4E-45 = 1.0, with float field operands +1.0 - 1.4E-45 = 1.0, with float field operands +1.0 * 1.4E-45 = 1.4E-45, with float field operands +1.0 / 1.4E-45 = Infinity, with float field operands +1.0 + 1.4E-45 = 1.0, with float a[i] operands +1.0 - 1.4E-45 = 1.0, with float a[i] operands +1.0 * 1.4E-45 = 1.4E-45, with float a[i] operands +1.0 / 1.4E-45 = Infinity, with float a[i] operands +1.0 + 1.4E-45 = 1.0, with float f(x) operands +1.0 - 1.4E-45 = 1.0, with float f(x) operands +1.0 * 1.4E-45 = 1.4E-45, with float f(x) operands +1.0 / 1.4E-45 = Infinity, with float f(x) operands +1.0 + 1.4E-45 = 1.0, with float lExpr operands +1.0 - 1.4E-45 = 1.0, with float lExpr operands +1.0 * 1.4E-45 = 1.4E-45, with float lExpr operands +1.0 / 1.4E-45 = Infinity, with float lExpr operands +1.0 + 1.4E-45 = 1.0, with float rExpr operands +1.0 - 1.4E-45 = 1.0, with float rExpr operands +1.0 * 1.4E-45 = 1.4E-45, with float rExpr operands +1.0 / 1.4E-45 = Infinity, with float rExpr operands +1.0 + 1.4E-45 = 1.0, with float exprs operands +1.0 - 1.4E-45 = 1.0, with float exprs operands +1.0 * 1.4E-45 = 1.4E-45, with float exprs operands +1.0 / 1.4E-45 = Infinity, with float exprs operands +1.0 + 3.4028235E38 = 3.4028235E38, with float param operands +1.0 - 3.4028235E38 = -3.4028235E38, with float param operands +1.0 * 3.4028235E38 = 3.4028235E38, with float param operands +1.0 / 3.4028235E38 = 2.938736E-39, with float param operands +1.0 + 3.4028235E38 = 3.4028235E38, with float local operands +1.0 - 3.4028235E38 = -3.4028235E38, with float local operands +1.0 * 3.4028235E38 = 3.4028235E38, with float local operands +1.0 / 3.4028235E38 = 2.938736E-39, with float local operands +1.0 + 3.4028235E38 = 3.4028235E38, with float static operands +1.0 - 3.4028235E38 = -3.4028235E38, with float static operands +1.0 * 3.4028235E38 = 3.4028235E38, with float static operands +1.0 / 3.4028235E38 = 2.938736E-39, with float static operands +1.0 + 3.4028235E38 = 3.4028235E38, with float field operands +1.0 - 3.4028235E38 = -3.4028235E38, with float field operands +1.0 * 3.4028235E38 = 3.4028235E38, with float field operands +1.0 / 3.4028235E38 = 2.938736E-39, with float field operands +1.0 + 3.4028235E38 = 3.4028235E38, with float a[i] operands +1.0 - 3.4028235E38 = -3.4028235E38, with float a[i] operands +1.0 * 3.4028235E38 = 3.4028235E38, with float a[i] operands +1.0 / 3.4028235E38 = 2.938736E-39, with float a[i] operands +1.0 + 3.4028235E38 = 3.4028235E38, with float f(x) operands +1.0 - 3.4028235E38 = -3.4028235E38, with float f(x) operands +1.0 * 3.4028235E38 = 3.4028235E38, with float f(x) operands +1.0 / 3.4028235E38 = 2.938736E-39, with float f(x) operands +1.0 + 3.4028235E38 = 3.4028235E38, with float lExpr operands +1.0 - 3.4028235E38 = -3.4028235E38, with float lExpr operands +1.0 * 3.4028235E38 = 3.4028235E38, with float lExpr operands +1.0 / 3.4028235E38 = 2.938736E-39, with float lExpr operands +1.0 + 3.4028235E38 = 3.4028235E38, with float rExpr operands +1.0 - 3.4028235E38 = -3.4028235E38, with float rExpr operands +1.0 * 3.4028235E38 = 3.4028235E38, with float rExpr operands +1.0 / 3.4028235E38 = 2.938736E-39, with float rExpr operands +1.0 + 3.4028235E38 = 3.4028235E38, with float exprs operands +1.0 - 3.4028235E38 = -3.4028235E38, with float exprs operands +1.0 * 3.4028235E38 = 3.4028235E38, with float exprs operands +1.0 / 3.4028235E38 = 2.938736E-39, with float exprs operands +1.0 + -1.4E-45 = 1.0, with float param operands +1.0 - -1.4E-45 = 1.0, with float param operands +1.0 * -1.4E-45 = -1.4E-45, with float param operands +1.0 / -1.4E-45 = -Infinity, with float param operands +1.0 + -1.4E-45 = 1.0, with float local operands +1.0 - -1.4E-45 = 1.0, with float local operands +1.0 * -1.4E-45 = -1.4E-45, with float local operands +1.0 / -1.4E-45 = -Infinity, with float local operands +1.0 + -1.4E-45 = 1.0, with float static operands +1.0 - -1.4E-45 = 1.0, with float static operands +1.0 * -1.4E-45 = -1.4E-45, with float static operands +1.0 / -1.4E-45 = -Infinity, with float static operands +1.0 + -1.4E-45 = 1.0, with float field operands +1.0 - -1.4E-45 = 1.0, with float field operands +1.0 * -1.4E-45 = -1.4E-45, with float field operands +1.0 / -1.4E-45 = -Infinity, with float field operands +1.0 + -1.4E-45 = 1.0, with float a[i] operands +1.0 - -1.4E-45 = 1.0, with float a[i] operands +1.0 * -1.4E-45 = -1.4E-45, with float a[i] operands +1.0 / -1.4E-45 = -Infinity, with float a[i] operands +1.0 + -1.4E-45 = 1.0, with float f(x) operands +1.0 - -1.4E-45 = 1.0, with float f(x) operands +1.0 * -1.4E-45 = -1.4E-45, with float f(x) operands +1.0 / -1.4E-45 = -Infinity, with float f(x) operands +1.0 + -1.4E-45 = 1.0, with float lExpr operands +1.0 - -1.4E-45 = 1.0, with float lExpr operands +1.0 * -1.4E-45 = -1.4E-45, with float lExpr operands +1.0 / -1.4E-45 = -Infinity, with float lExpr operands +1.0 + -1.4E-45 = 1.0, with float rExpr operands +1.0 - -1.4E-45 = 1.0, with float rExpr operands +1.0 * -1.4E-45 = -1.4E-45, with float rExpr operands +1.0 / -1.4E-45 = -Infinity, with float rExpr operands +1.0 + -1.4E-45 = 1.0, with float exprs operands +1.0 - -1.4E-45 = 1.0, with float exprs operands +1.0 * -1.4E-45 = -1.4E-45, with float exprs operands +1.0 / -1.4E-45 = -Infinity, with float exprs operands +1.0 + -3.4028235E38 = -3.4028235E38, with float param operands +1.0 - -3.4028235E38 = 3.4028235E38, with float param operands +1.0 * -3.4028235E38 = -3.4028235E38, with float param operands +1.0 / -3.4028235E38 = -2.938736E-39, with float param operands +1.0 + -3.4028235E38 = -3.4028235E38, with float local operands +1.0 - -3.4028235E38 = 3.4028235E38, with float local operands +1.0 * -3.4028235E38 = -3.4028235E38, with float local operands +1.0 / -3.4028235E38 = -2.938736E-39, with float local operands +1.0 + -3.4028235E38 = -3.4028235E38, with float static operands +1.0 - -3.4028235E38 = 3.4028235E38, with float static operands +1.0 * -3.4028235E38 = -3.4028235E38, with float static operands +1.0 / -3.4028235E38 = -2.938736E-39, with float static operands +1.0 + -3.4028235E38 = -3.4028235E38, with float field operands +1.0 - -3.4028235E38 = 3.4028235E38, with float field operands +1.0 * -3.4028235E38 = -3.4028235E38, with float field operands +1.0 / -3.4028235E38 = -2.938736E-39, with float field operands +1.0 + -3.4028235E38 = -3.4028235E38, with float a[i] operands +1.0 - -3.4028235E38 = 3.4028235E38, with float a[i] operands +1.0 * -3.4028235E38 = -3.4028235E38, with float a[i] operands +1.0 / -3.4028235E38 = -2.938736E-39, with float a[i] operands +1.0 + -3.4028235E38 = -3.4028235E38, with float f(x) operands +1.0 - -3.4028235E38 = 3.4028235E38, with float f(x) operands +1.0 * -3.4028235E38 = -3.4028235E38, with float f(x) operands +1.0 / -3.4028235E38 = -2.938736E-39, with float f(x) operands +1.0 + -3.4028235E38 = -3.4028235E38, with float lExpr operands +1.0 - -3.4028235E38 = 3.4028235E38, with float lExpr operands +1.0 * -3.4028235E38 = -3.4028235E38, with float lExpr operands +1.0 / -3.4028235E38 = -2.938736E-39, with float lExpr operands +1.0 + -3.4028235E38 = -3.4028235E38, with float rExpr operands +1.0 - -3.4028235E38 = 3.4028235E38, with float rExpr operands +1.0 * -3.4028235E38 = -3.4028235E38, with float rExpr operands +1.0 / -3.4028235E38 = -2.938736E-39, with float rExpr operands +1.0 + -3.4028235E38 = -3.4028235E38, with float exprs operands +1.0 - -3.4028235E38 = 3.4028235E38, with float exprs operands +1.0 * -3.4028235E38 = -3.4028235E38, with float exprs operands +1.0 / -3.4028235E38 = -2.938736E-39, with float exprs operands +1.0 + -1.0 = 0.0, with float param operands +1.0 - -1.0 = 2.0, with float param operands +1.0 * -1.0 = -1.0, with float param operands +1.0 / -1.0 = -1.0, with float param operands +1.0 + -1.0 = 0.0, with float local operands +1.0 - -1.0 = 2.0, with float local operands +1.0 * -1.0 = -1.0, with float local operands +1.0 / -1.0 = -1.0, with float local operands +1.0 + -1.0 = 0.0, with float static operands +1.0 - -1.0 = 2.0, with float static operands +1.0 * -1.0 = -1.0, with float static operands +1.0 / -1.0 = -1.0, with float static operands +1.0 + -1.0 = 0.0, with float field operands +1.0 - -1.0 = 2.0, with float field operands +1.0 * -1.0 = -1.0, with float field operands +1.0 / -1.0 = -1.0, with float field operands +1.0 + -1.0 = 0.0, with float a[i] operands +1.0 - -1.0 = 2.0, with float a[i] operands +1.0 * -1.0 = -1.0, with float a[i] operands +1.0 / -1.0 = -1.0, with float a[i] operands +1.0 + -1.0 = 0.0, with float f(x) operands +1.0 - -1.0 = 2.0, with float f(x) operands +1.0 * -1.0 = -1.0, with float f(x) operands +1.0 / -1.0 = -1.0, with float f(x) operands +1.0 + -1.0 = 0.0, with float lExpr operands +1.0 - -1.0 = 2.0, with float lExpr operands +1.0 * -1.0 = -1.0, with float lExpr operands +1.0 / -1.0 = -1.0, with float lExpr operands +1.0 + -1.0 = 0.0, with float rExpr operands +1.0 - -1.0 = 2.0, with float rExpr operands +1.0 * -1.0 = -1.0, with float rExpr operands +1.0 / -1.0 = -1.0, with float rExpr operands +1.0 + -1.0 = 0.0, with float exprs operands +1.0 - -1.0 = 2.0, with float exprs operands +1.0 * -1.0 = -1.0, with float exprs operands +1.0 / -1.0 = -1.0, with float exprs operands +1.0 + 1.0 = 2.0, with float param operands +1.0 - 1.0 = 0.0, with float param operands +1.0 * 1.0 = 1.0, with float param operands +1.0 / 1.0 = 1.0, with float param operands +1.0 + 1.0 = 2.0, with float local operands +1.0 - 1.0 = 0.0, with float local operands +1.0 * 1.0 = 1.0, with float local operands +1.0 / 1.0 = 1.0, with float local operands +1.0 + 1.0 = 2.0, with float static operands +1.0 - 1.0 = 0.0, with float static operands +1.0 * 1.0 = 1.0, with float static operands +1.0 / 1.0 = 1.0, with float static operands +1.0 + 1.0 = 2.0, with float field operands +1.0 - 1.0 = 0.0, with float field operands +1.0 * 1.0 = 1.0, with float field operands +1.0 / 1.0 = 1.0, with float field operands +1.0 + 1.0 = 2.0, with float a[i] operands +1.0 - 1.0 = 0.0, with float a[i] operands +1.0 * 1.0 = 1.0, with float a[i] operands +1.0 / 1.0 = 1.0, with float a[i] operands +1.0 + 1.0 = 2.0, with float f(x) operands +1.0 - 1.0 = 0.0, with float f(x) operands +1.0 * 1.0 = 1.0, with float f(x) operands +1.0 / 1.0 = 1.0, with float f(x) operands +1.0 + 1.0 = 2.0, with float lExpr operands +1.0 - 1.0 = 0.0, with float lExpr operands +1.0 * 1.0 = 1.0, with float lExpr operands +1.0 / 1.0 = 1.0, with float lExpr operands +1.0 + 1.0 = 2.0, with float rExpr operands +1.0 - 1.0 = 0.0, with float rExpr operands +1.0 * 1.0 = 1.0, with float rExpr operands +1.0 / 1.0 = 1.0, with float rExpr operands +1.0 + 1.0 = 2.0, with float exprs operands +1.0 - 1.0 = 0.0, with float exprs operands +1.0 * 1.0 = 1.0, with float exprs operands +1.0 / 1.0 = 1.0, with float exprs operands +1.0 + -0.0 = 1.0, with float param operands +1.0 - -0.0 = 1.0, with float param operands +1.0 * -0.0 = -0.0, with float param operands +1.0 / -0.0 = -Infinity, with float param operands +1.0 + -0.0 = 1.0, with float local operands +1.0 - -0.0 = 1.0, with float local operands +1.0 * -0.0 = -0.0, with float local operands +1.0 / -0.0 = -Infinity, with float local operands +1.0 + -0.0 = 1.0, with float static operands +1.0 - -0.0 = 1.0, with float static operands +1.0 * -0.0 = -0.0, with float static operands +1.0 / -0.0 = -Infinity, with float static operands +1.0 + -0.0 = 1.0, with float field operands +1.0 - -0.0 = 1.0, with float field operands +1.0 * -0.0 = -0.0, with float field operands +1.0 / -0.0 = -Infinity, with float field operands +1.0 + -0.0 = 1.0, with float a[i] operands +1.0 - -0.0 = 1.0, with float a[i] operands +1.0 * -0.0 = -0.0, with float a[i] operands +1.0 / -0.0 = -Infinity, with float a[i] operands +1.0 + -0.0 = 1.0, with float f(x) operands +1.0 - -0.0 = 1.0, with float f(x) operands +1.0 * -0.0 = -0.0, with float f(x) operands +1.0 / -0.0 = -Infinity, with float f(x) operands +1.0 + -0.0 = 1.0, with float lExpr operands +1.0 - -0.0 = 1.0, with float lExpr operands +1.0 * -0.0 = -0.0, with float lExpr operands +1.0 / -0.0 = -Infinity, with float lExpr operands +1.0 + 0.0 = 1.0, with float rExpr operands +1.0 - 0.0 = 1.0, with float rExpr operands +1.0 * 0.0 = 0.0, with float rExpr operands +1.0 / 0.0 = Infinity, with float rExpr operands +1.0 + 0.0 = 1.0, with float exprs operands +1.0 - 0.0 = 1.0, with float exprs operands +1.0 * 0.0 = 0.0, with float exprs operands +1.0 / 0.0 = Infinity, with float exprs operands +1.0 + 0.0 = 1.0, with float param operands +1.0 - 0.0 = 1.0, with float param operands +1.0 * 0.0 = 0.0, with float param operands +1.0 / 0.0 = Infinity, with float param operands +1.0 + 0.0 = 1.0, with float local operands +1.0 - 0.0 = 1.0, with float local operands +1.0 * 0.0 = 0.0, with float local operands +1.0 / 0.0 = Infinity, with float local operands +1.0 + 0.0 = 1.0, with float static operands +1.0 - 0.0 = 1.0, with float static operands +1.0 * 0.0 = 0.0, with float static operands +1.0 / 0.0 = Infinity, with float static operands +1.0 + 0.0 = 1.0, with float field operands +1.0 - 0.0 = 1.0, with float field operands +1.0 * 0.0 = 0.0, with float field operands +1.0 / 0.0 = Infinity, with float field operands +1.0 + 0.0 = 1.0, with float a[i] operands +1.0 - 0.0 = 1.0, with float a[i] operands +1.0 * 0.0 = 0.0, with float a[i] operands +1.0 / 0.0 = Infinity, with float a[i] operands +1.0 + 0.0 = 1.0, with float f(x) operands +1.0 - 0.0 = 1.0, with float f(x) operands +1.0 * 0.0 = 0.0, with float f(x) operands +1.0 / 0.0 = Infinity, with float f(x) operands +1.0 + 0.0 = 1.0, with float lExpr operands +1.0 - 0.0 = 1.0, with float lExpr operands +1.0 * 0.0 = 0.0, with float lExpr operands +1.0 / 0.0 = Infinity, with float lExpr operands +1.0 + 0.0 = 1.0, with float rExpr operands +1.0 - 0.0 = 1.0, with float rExpr operands +1.0 * 0.0 = 0.0, with float rExpr operands +1.0 / 0.0 = Infinity, with float rExpr operands +1.0 + 0.0 = 1.0, with float exprs operands +1.0 - 0.0 = 1.0, with float exprs operands +1.0 * 0.0 = 0.0, with float exprs operands +1.0 / 0.0 = Infinity, with float exprs operands +1.0 + -Infinity = -Infinity, with float param operands +1.0 - -Infinity = Infinity, with float param operands +1.0 * -Infinity = -Infinity, with float param operands +1.0 / -Infinity = -0.0, with float param operands +1.0 + -Infinity = -Infinity, with float local operands +1.0 - -Infinity = Infinity, with float local operands +1.0 * -Infinity = -Infinity, with float local operands +1.0 / -Infinity = -0.0, with float local operands +1.0 + -Infinity = -Infinity, with float static operands +1.0 - -Infinity = Infinity, with float static operands +1.0 * -Infinity = -Infinity, with float static operands +1.0 / -Infinity = -0.0, with float static operands +1.0 + -Infinity = -Infinity, with float field operands +1.0 - -Infinity = Infinity, with float field operands +1.0 * -Infinity = -Infinity, with float field operands +1.0 / -Infinity = -0.0, with float field operands +1.0 + -Infinity = -Infinity, with float a[i] operands +1.0 - -Infinity = Infinity, with float a[i] operands +1.0 * -Infinity = -Infinity, with float a[i] operands +1.0 / -Infinity = -0.0, with float a[i] operands +1.0 + -Infinity = -Infinity, with float f(x) operands +1.0 - -Infinity = Infinity, with float f(x) operands +1.0 * -Infinity = -Infinity, with float f(x) operands +1.0 / -Infinity = -0.0, with float f(x) operands +1.0 + -Infinity = -Infinity, with float lExpr operands +1.0 - -Infinity = Infinity, with float lExpr operands +1.0 * -Infinity = -Infinity, with float lExpr operands +1.0 / -Infinity = -0.0, with float lExpr operands +1.0 + -Infinity = -Infinity, with float rExpr operands +1.0 - -Infinity = Infinity, with float rExpr operands +1.0 * -Infinity = -Infinity, with float rExpr operands +1.0 / -Infinity = -0.0, with float rExpr operands +1.0 + -Infinity = -Infinity, with float exprs operands +1.0 - -Infinity = Infinity, with float exprs operands +1.0 * -Infinity = -Infinity, with float exprs operands +1.0 / -Infinity = -0.0, with float exprs operands +1.0 + Infinity = Infinity, with float param operands +1.0 - Infinity = -Infinity, with float param operands +1.0 * Infinity = Infinity, with float param operands +1.0 / Infinity = 0.0, with float param operands +1.0 + Infinity = Infinity, with float local operands +1.0 - Infinity = -Infinity, with float local operands +1.0 * Infinity = Infinity, with float local operands +1.0 / Infinity = 0.0, with float local operands +1.0 + Infinity = Infinity, with float static operands +1.0 - Infinity = -Infinity, with float static operands +1.0 * Infinity = Infinity, with float static operands +1.0 / Infinity = 0.0, with float static operands +1.0 + Infinity = Infinity, with float field operands +1.0 - Infinity = -Infinity, with float field operands +1.0 * Infinity = Infinity, with float field operands +1.0 / Infinity = 0.0, with float field operands +1.0 + Infinity = Infinity, with float a[i] operands +1.0 - Infinity = -Infinity, with float a[i] operands +1.0 * Infinity = Infinity, with float a[i] operands +1.0 / Infinity = 0.0, with float a[i] operands +1.0 + Infinity = Infinity, with float f(x) operands +1.0 - Infinity = -Infinity, with float f(x) operands +1.0 * Infinity = Infinity, with float f(x) operands +1.0 / Infinity = 0.0, with float f(x) operands +1.0 + Infinity = Infinity, with float lExpr operands +1.0 - Infinity = -Infinity, with float lExpr operands +1.0 * Infinity = Infinity, with float lExpr operands +1.0 / Infinity = 0.0, with float lExpr operands +1.0 + Infinity = Infinity, with float rExpr operands +1.0 - Infinity = -Infinity, with float rExpr operands +1.0 * Infinity = Infinity, with float rExpr operands +1.0 / Infinity = 0.0, with float rExpr operands +1.0 + Infinity = Infinity, with float exprs operands +1.0 - Infinity = -Infinity, with float exprs operands +1.0 * Infinity = Infinity, with float exprs operands +1.0 / Infinity = 0.0, with float exprs operands +1.0 + NaN = NaN, with float param operands +1.0 - NaN = NaN, with float param operands +1.0 * NaN = NaN, with float param operands +1.0 / NaN = NaN, with float param operands +1.0 + NaN = NaN, with float local operands +1.0 - NaN = NaN, with float local operands +1.0 * NaN = NaN, with float local operands +1.0 / NaN = NaN, with float local operands +1.0 + NaN = NaN, with float static operands +1.0 - NaN = NaN, with float static operands +1.0 * NaN = NaN, with float static operands +1.0 / NaN = NaN, with float static operands +1.0 + NaN = NaN, with float field operands +1.0 - NaN = NaN, with float field operands +1.0 * NaN = NaN, with float field operands +1.0 / NaN = NaN, with float field operands +1.0 + NaN = NaN, with float a[i] operands +1.0 - NaN = NaN, with float a[i] operands +1.0 * NaN = NaN, with float a[i] operands +1.0 / NaN = NaN, with float a[i] operands +1.0 + NaN = NaN, with float f(x) operands +1.0 - NaN = NaN, with float f(x) operands +1.0 * NaN = NaN, with float f(x) operands +1.0 / NaN = NaN, with float f(x) operands +1.0 + NaN = NaN, with float lExpr operands +1.0 - NaN = NaN, with float lExpr operands +1.0 * NaN = NaN, with float lExpr operands +1.0 / NaN = NaN, with float lExpr operands +1.0 + NaN = NaN, with float rExpr operands +1.0 - NaN = NaN, with float rExpr operands +1.0 * NaN = NaN, with float rExpr operands +1.0 / NaN = NaN, with float rExpr operands +1.0 + NaN = NaN, with float exprs operands +1.0 - NaN = NaN, with float exprs operands +1.0 * NaN = NaN, with float exprs operands +1.0 / NaN = NaN, with float exprs operands +-0.0 + 1.4E-45 = 1.4E-45, with float param operands +-0.0 - 1.4E-45 = -1.4E-45, with float param operands +-0.0 * 1.4E-45 = -0.0, with float param operands +-0.0 / 1.4E-45 = -0.0, with float param operands +-0.0 + 1.4E-45 = 1.4E-45, with float local operands +-0.0 - 1.4E-45 = -1.4E-45, with float local operands +-0.0 * 1.4E-45 = -0.0, with float local operands +-0.0 / 1.4E-45 = -0.0, with float local operands +-0.0 + 1.4E-45 = 1.4E-45, with float static operands +-0.0 - 1.4E-45 = -1.4E-45, with float static operands +-0.0 * 1.4E-45 = -0.0, with float static operands +-0.0 / 1.4E-45 = -0.0, with float static operands +-0.0 + 1.4E-45 = 1.4E-45, with float field operands +-0.0 - 1.4E-45 = -1.4E-45, with float field operands +-0.0 * 1.4E-45 = -0.0, with float field operands +-0.0 / 1.4E-45 = -0.0, with float field operands +-0.0 + 1.4E-45 = 1.4E-45, with float a[i] operands +-0.0 - 1.4E-45 = -1.4E-45, with float a[i] operands +-0.0 * 1.4E-45 = -0.0, with float a[i] operands +-0.0 / 1.4E-45 = -0.0, with float a[i] operands +-0.0 + 1.4E-45 = 1.4E-45, with float f(x) operands +-0.0 - 1.4E-45 = -1.4E-45, with float f(x) operands +-0.0 * 1.4E-45 = -0.0, with float f(x) operands +-0.0 / 1.4E-45 = -0.0, with float f(x) operands +0.0 + 1.4E-45 = 1.4E-45, with float lExpr operands +0.0 - 1.4E-45 = -1.4E-45, with float lExpr operands +0.0 * 1.4E-45 = 0.0, with float lExpr operands +0.0 / 1.4E-45 = 0.0, with float lExpr operands +-0.0 + 1.4E-45 = 1.4E-45, with float rExpr operands +-0.0 - 1.4E-45 = -1.4E-45, with float rExpr operands +-0.0 * 1.4E-45 = -0.0, with float rExpr operands +-0.0 / 1.4E-45 = -0.0, with float rExpr operands +0.0 + 1.4E-45 = 1.4E-45, with float exprs operands +0.0 - 1.4E-45 = -1.4E-45, with float exprs operands +0.0 * 1.4E-45 = 0.0, with float exprs operands +0.0 / 1.4E-45 = 0.0, with float exprs operands +-0.0 + 3.4028235E38 = 3.4028235E38, with float param operands +-0.0 - 3.4028235E38 = -3.4028235E38, with float param operands +-0.0 * 3.4028235E38 = -0.0, with float param operands +-0.0 / 3.4028235E38 = -0.0, with float param operands +-0.0 + 3.4028235E38 = 3.4028235E38, with float local operands +-0.0 - 3.4028235E38 = -3.4028235E38, with float local operands +-0.0 * 3.4028235E38 = -0.0, with float local operands +-0.0 / 3.4028235E38 = -0.0, with float local operands +-0.0 + 3.4028235E38 = 3.4028235E38, with float static operands +-0.0 - 3.4028235E38 = -3.4028235E38, with float static operands +-0.0 * 3.4028235E38 = -0.0, with float static operands +-0.0 / 3.4028235E38 = -0.0, with float static operands +-0.0 + 3.4028235E38 = 3.4028235E38, with float field operands +-0.0 - 3.4028235E38 = -3.4028235E38, with float field operands +-0.0 * 3.4028235E38 = -0.0, with float field operands +-0.0 / 3.4028235E38 = -0.0, with float field operands +-0.0 + 3.4028235E38 = 3.4028235E38, with float a[i] operands +-0.0 - 3.4028235E38 = -3.4028235E38, with float a[i] operands +-0.0 * 3.4028235E38 = -0.0, with float a[i] operands +-0.0 / 3.4028235E38 = -0.0, with float a[i] operands +-0.0 + 3.4028235E38 = 3.4028235E38, with float f(x) operands +-0.0 - 3.4028235E38 = -3.4028235E38, with float f(x) operands +-0.0 * 3.4028235E38 = -0.0, with float f(x) operands +-0.0 / 3.4028235E38 = -0.0, with float f(x) operands +0.0 + 3.4028235E38 = 3.4028235E38, with float lExpr operands +0.0 - 3.4028235E38 = -3.4028235E38, with float lExpr operands +0.0 * 3.4028235E38 = 0.0, with float lExpr operands +0.0 / 3.4028235E38 = 0.0, with float lExpr operands +-0.0 + 3.4028235E38 = 3.4028235E38, with float rExpr operands +-0.0 - 3.4028235E38 = -3.4028235E38, with float rExpr operands +-0.0 * 3.4028235E38 = -0.0, with float rExpr operands +-0.0 / 3.4028235E38 = -0.0, with float rExpr operands +0.0 + 3.4028235E38 = 3.4028235E38, with float exprs operands +0.0 - 3.4028235E38 = -3.4028235E38, with float exprs operands +0.0 * 3.4028235E38 = 0.0, with float exprs operands +0.0 / 3.4028235E38 = 0.0, with float exprs operands +-0.0 + -1.4E-45 = -1.4E-45, with float param operands +-0.0 - -1.4E-45 = 1.4E-45, with float param operands +-0.0 * -1.4E-45 = 0.0, with float param operands +-0.0 / -1.4E-45 = 0.0, with float param operands +-0.0 + -1.4E-45 = -1.4E-45, with float local operands +-0.0 - -1.4E-45 = 1.4E-45, with float local operands +-0.0 * -1.4E-45 = 0.0, with float local operands +-0.0 / -1.4E-45 = 0.0, with float local operands +-0.0 + -1.4E-45 = -1.4E-45, with float static operands +-0.0 - -1.4E-45 = 1.4E-45, with float static operands +-0.0 * -1.4E-45 = 0.0, with float static operands +-0.0 / -1.4E-45 = 0.0, with float static operands +-0.0 + -1.4E-45 = -1.4E-45, with float field operands +-0.0 - -1.4E-45 = 1.4E-45, with float field operands +-0.0 * -1.4E-45 = 0.0, with float field operands +-0.0 / -1.4E-45 = 0.0, with float field operands +-0.0 + -1.4E-45 = -1.4E-45, with float a[i] operands +-0.0 - -1.4E-45 = 1.4E-45, with float a[i] operands +-0.0 * -1.4E-45 = 0.0, with float a[i] operands +-0.0 / -1.4E-45 = 0.0, with float a[i] operands +-0.0 + -1.4E-45 = -1.4E-45, with float f(x) operands +-0.0 - -1.4E-45 = 1.4E-45, with float f(x) operands +-0.0 * -1.4E-45 = 0.0, with float f(x) operands +-0.0 / -1.4E-45 = 0.0, with float f(x) operands +0.0 + -1.4E-45 = -1.4E-45, with float lExpr operands +0.0 - -1.4E-45 = 1.4E-45, with float lExpr operands +0.0 * -1.4E-45 = -0.0, with float lExpr operands +0.0 / -1.4E-45 = -0.0, with float lExpr operands +-0.0 + -1.4E-45 = -1.4E-45, with float rExpr operands +-0.0 - -1.4E-45 = 1.4E-45, with float rExpr operands +-0.0 * -1.4E-45 = 0.0, with float rExpr operands +-0.0 / -1.4E-45 = 0.0, with float rExpr operands +0.0 + -1.4E-45 = -1.4E-45, with float exprs operands +0.0 - -1.4E-45 = 1.4E-45, with float exprs operands +0.0 * -1.4E-45 = -0.0, with float exprs operands +0.0 / -1.4E-45 = -0.0, with float exprs operands +-0.0 + -3.4028235E38 = -3.4028235E38, with float param operands +-0.0 - -3.4028235E38 = 3.4028235E38, with float param operands +-0.0 * -3.4028235E38 = 0.0, with float param operands +-0.0 / -3.4028235E38 = 0.0, with float param operands +-0.0 + -3.4028235E38 = -3.4028235E38, with float local operands +-0.0 - -3.4028235E38 = 3.4028235E38, with float local operands +-0.0 * -3.4028235E38 = 0.0, with float local operands +-0.0 / -3.4028235E38 = 0.0, with float local operands +-0.0 + -3.4028235E38 = -3.4028235E38, with float static operands +-0.0 - -3.4028235E38 = 3.4028235E38, with float static operands +-0.0 * -3.4028235E38 = 0.0, with float static operands +-0.0 / -3.4028235E38 = 0.0, with float static operands +-0.0 + -3.4028235E38 = -3.4028235E38, with float field operands +-0.0 - -3.4028235E38 = 3.4028235E38, with float field operands +-0.0 * -3.4028235E38 = 0.0, with float field operands +-0.0 / -3.4028235E38 = 0.0, with float field operands +-0.0 + -3.4028235E38 = -3.4028235E38, with float a[i] operands +-0.0 - -3.4028235E38 = 3.4028235E38, with float a[i] operands +-0.0 * -3.4028235E38 = 0.0, with float a[i] operands +-0.0 / -3.4028235E38 = 0.0, with float a[i] operands +-0.0 + -3.4028235E38 = -3.4028235E38, with float f(x) operands +-0.0 - -3.4028235E38 = 3.4028235E38, with float f(x) operands +-0.0 * -3.4028235E38 = 0.0, with float f(x) operands +-0.0 / -3.4028235E38 = 0.0, with float f(x) operands +0.0 + -3.4028235E38 = -3.4028235E38, with float lExpr operands +0.0 - -3.4028235E38 = 3.4028235E38, with float lExpr operands +0.0 * -3.4028235E38 = -0.0, with float lExpr operands +0.0 / -3.4028235E38 = -0.0, with float lExpr operands +-0.0 + -3.4028235E38 = -3.4028235E38, with float rExpr operands +-0.0 - -3.4028235E38 = 3.4028235E38, with float rExpr operands +-0.0 * -3.4028235E38 = 0.0, with float rExpr operands +-0.0 / -3.4028235E38 = 0.0, with float rExpr operands +0.0 + -3.4028235E38 = -3.4028235E38, with float exprs operands +0.0 - -3.4028235E38 = 3.4028235E38, with float exprs operands +0.0 * -3.4028235E38 = -0.0, with float exprs operands +0.0 / -3.4028235E38 = -0.0, with float exprs operands +-0.0 + -1.0 = -1.0, with float param operands +-0.0 - -1.0 = 1.0, with float param operands +-0.0 * -1.0 = 0.0, with float param operands +-0.0 / -1.0 = 0.0, with float param operands +-0.0 + -1.0 = -1.0, with float local operands +-0.0 - -1.0 = 1.0, with float local operands +-0.0 * -1.0 = 0.0, with float local operands +-0.0 / -1.0 = 0.0, with float local operands +-0.0 + -1.0 = -1.0, with float static operands +-0.0 - -1.0 = 1.0, with float static operands +-0.0 * -1.0 = 0.0, with float static operands +-0.0 / -1.0 = 0.0, with float static operands +-0.0 + -1.0 = -1.0, with float field operands +-0.0 - -1.0 = 1.0, with float field operands +-0.0 * -1.0 = 0.0, with float field operands +-0.0 / -1.0 = 0.0, with float field operands +-0.0 + -1.0 = -1.0, with float a[i] operands +-0.0 - -1.0 = 1.0, with float a[i] operands +-0.0 * -1.0 = 0.0, with float a[i] operands +-0.0 / -1.0 = 0.0, with float a[i] operands +-0.0 + -1.0 = -1.0, with float f(x) operands +-0.0 - -1.0 = 1.0, with float f(x) operands +-0.0 * -1.0 = 0.0, with float f(x) operands +-0.0 / -1.0 = 0.0, with float f(x) operands +0.0 + -1.0 = -1.0, with float lExpr operands +0.0 - -1.0 = 1.0, with float lExpr operands +0.0 * -1.0 = -0.0, with float lExpr operands +0.0 / -1.0 = -0.0, with float lExpr operands +-0.0 + -1.0 = -1.0, with float rExpr operands +-0.0 - -1.0 = 1.0, with float rExpr operands +-0.0 * -1.0 = 0.0, with float rExpr operands +-0.0 / -1.0 = 0.0, with float rExpr operands +0.0 + -1.0 = -1.0, with float exprs operands +0.0 - -1.0 = 1.0, with float exprs operands +0.0 * -1.0 = -0.0, with float exprs operands +0.0 / -1.0 = -0.0, with float exprs operands +-0.0 + 1.0 = 1.0, with float param operands +-0.0 - 1.0 = -1.0, with float param operands +-0.0 * 1.0 = -0.0, with float param operands +-0.0 / 1.0 = -0.0, with float param operands +-0.0 + 1.0 = 1.0, with float local operands +-0.0 - 1.0 = -1.0, with float local operands +-0.0 * 1.0 = -0.0, with float local operands +-0.0 / 1.0 = -0.0, with float local operands +-0.0 + 1.0 = 1.0, with float static operands +-0.0 - 1.0 = -1.0, with float static operands +-0.0 * 1.0 = -0.0, with float static operands +-0.0 / 1.0 = -0.0, with float static operands +-0.0 + 1.0 = 1.0, with float field operands +-0.0 - 1.0 = -1.0, with float field operands +-0.0 * 1.0 = -0.0, with float field operands +-0.0 / 1.0 = -0.0, with float field operands +-0.0 + 1.0 = 1.0, with float a[i] operands +-0.0 - 1.0 = -1.0, with float a[i] operands +-0.0 * 1.0 = -0.0, with float a[i] operands +-0.0 / 1.0 = -0.0, with float a[i] operands +-0.0 + 1.0 = 1.0, with float f(x) operands +-0.0 - 1.0 = -1.0, with float f(x) operands +-0.0 * 1.0 = -0.0, with float f(x) operands +-0.0 / 1.0 = -0.0, with float f(x) operands +0.0 + 1.0 = 1.0, with float lExpr operands +0.0 - 1.0 = -1.0, with float lExpr operands +0.0 * 1.0 = 0.0, with float lExpr operands +0.0 / 1.0 = 0.0, with float lExpr operands +-0.0 + 1.0 = 1.0, with float rExpr operands +-0.0 - 1.0 = -1.0, with float rExpr operands +-0.0 * 1.0 = -0.0, with float rExpr operands +-0.0 / 1.0 = -0.0, with float rExpr operands +0.0 + 1.0 = 1.0, with float exprs operands +0.0 - 1.0 = -1.0, with float exprs operands +0.0 * 1.0 = 0.0, with float exprs operands +0.0 / 1.0 = 0.0, with float exprs operands +-0.0 + -0.0 = -0.0, with float param operands +-0.0 - -0.0 = 0.0, with float param operands +-0.0 * -0.0 = 0.0, with float param operands +-0.0 / -0.0 = NaN, with float param operands +-0.0 + -0.0 = -0.0, with float local operands +-0.0 - -0.0 = 0.0, with float local operands +-0.0 * -0.0 = 0.0, with float local operands +-0.0 / -0.0 = NaN, with float local operands +-0.0 + -0.0 = -0.0, with float static operands +-0.0 - -0.0 = 0.0, with float static operands +-0.0 * -0.0 = 0.0, with float static operands +-0.0 / -0.0 = NaN, with float static operands +-0.0 + -0.0 = -0.0, with float field operands +-0.0 - -0.0 = 0.0, with float field operands +-0.0 * -0.0 = 0.0, with float field operands +-0.0 / -0.0 = NaN, with float field operands +-0.0 + -0.0 = -0.0, with float a[i] operands +-0.0 - -0.0 = 0.0, with float a[i] operands +-0.0 * -0.0 = 0.0, with float a[i] operands +-0.0 / -0.0 = NaN, with float a[i] operands +-0.0 + -0.0 = -0.0, with float f(x) operands +-0.0 - -0.0 = 0.0, with float f(x) operands +-0.0 * -0.0 = 0.0, with float f(x) operands +-0.0 / -0.0 = NaN, with float f(x) operands +0.0 + -0.0 = 0.0, with float lExpr operands +0.0 - -0.0 = 0.0, with float lExpr operands +0.0 * -0.0 = -0.0, with float lExpr operands +0.0 / -0.0 = NaN, with float lExpr operands +-0.0 + 0.0 = 0.0, with float rExpr operands +-0.0 - 0.0 = -0.0, with float rExpr operands +-0.0 * 0.0 = -0.0, with float rExpr operands +-0.0 / 0.0 = NaN, with float rExpr operands +0.0 + 0.0 = 0.0, with float exprs operands +0.0 - 0.0 = 0.0, with float exprs operands +0.0 * 0.0 = 0.0, with float exprs operands +0.0 / 0.0 = NaN, with float exprs operands +-0.0 + 0.0 = 0.0, with float param operands +-0.0 - 0.0 = -0.0, with float param operands +-0.0 * 0.0 = -0.0, with float param operands +-0.0 / 0.0 = NaN, with float param operands +-0.0 + 0.0 = 0.0, with float local operands +-0.0 - 0.0 = -0.0, with float local operands +-0.0 * 0.0 = -0.0, with float local operands +-0.0 / 0.0 = NaN, with float local operands +-0.0 + 0.0 = 0.0, with float static operands +-0.0 - 0.0 = -0.0, with float static operands +-0.0 * 0.0 = -0.0, with float static operands +-0.0 / 0.0 = NaN, with float static operands +-0.0 + 0.0 = 0.0, with float field operands +-0.0 - 0.0 = -0.0, with float field operands +-0.0 * 0.0 = -0.0, with float field operands +-0.0 / 0.0 = NaN, with float field operands +-0.0 + 0.0 = 0.0, with float a[i] operands +-0.0 - 0.0 = -0.0, with float a[i] operands +-0.0 * 0.0 = -0.0, with float a[i] operands +-0.0 / 0.0 = NaN, with float a[i] operands +-0.0 + 0.0 = 0.0, with float f(x) operands +-0.0 - 0.0 = -0.0, with float f(x) operands +-0.0 * 0.0 = -0.0, with float f(x) operands +-0.0 / 0.0 = NaN, with float f(x) operands +0.0 + 0.0 = 0.0, with float lExpr operands +0.0 - 0.0 = 0.0, with float lExpr operands +0.0 * 0.0 = 0.0, with float lExpr operands +0.0 / 0.0 = NaN, with float lExpr operands +-0.0 + 0.0 = 0.0, with float rExpr operands +-0.0 - 0.0 = -0.0, with float rExpr operands +-0.0 * 0.0 = -0.0, with float rExpr operands +-0.0 / 0.0 = NaN, with float rExpr operands +0.0 + 0.0 = 0.0, with float exprs operands +0.0 - 0.0 = 0.0, with float exprs operands +0.0 * 0.0 = 0.0, with float exprs operands +0.0 / 0.0 = NaN, with float exprs operands +-0.0 + -Infinity = -Infinity, with float param operands +-0.0 - -Infinity = Infinity, with float param operands +-0.0 * -Infinity = NaN, with float param operands +-0.0 / -Infinity = 0.0, with float param operands +-0.0 + -Infinity = -Infinity, with float local operands +-0.0 - -Infinity = Infinity, with float local operands +-0.0 * -Infinity = NaN, with float local operands +-0.0 / -Infinity = 0.0, with float local operands +-0.0 + -Infinity = -Infinity, with float static operands +-0.0 - -Infinity = Infinity, with float static operands +-0.0 * -Infinity = NaN, with float static operands +-0.0 / -Infinity = 0.0, with float static operands +-0.0 + -Infinity = -Infinity, with float field operands +-0.0 - -Infinity = Infinity, with float field operands +-0.0 * -Infinity = NaN, with float field operands +-0.0 / -Infinity = 0.0, with float field operands +-0.0 + -Infinity = -Infinity, with float a[i] operands +-0.0 - -Infinity = Infinity, with float a[i] operands +-0.0 * -Infinity = NaN, with float a[i] operands +-0.0 / -Infinity = 0.0, with float a[i] operands +-0.0 + -Infinity = -Infinity, with float f(x) operands +-0.0 - -Infinity = Infinity, with float f(x) operands +-0.0 * -Infinity = NaN, with float f(x) operands +-0.0 / -Infinity = 0.0, with float f(x) operands +0.0 + -Infinity = -Infinity, with float lExpr operands +0.0 - -Infinity = Infinity, with float lExpr operands +0.0 * -Infinity = NaN, with float lExpr operands +0.0 / -Infinity = -0.0, with float lExpr operands +-0.0 + -Infinity = -Infinity, with float rExpr operands +-0.0 - -Infinity = Infinity, with float rExpr operands +-0.0 * -Infinity = NaN, with float rExpr operands +-0.0 / -Infinity = 0.0, with float rExpr operands +0.0 + -Infinity = -Infinity, with float exprs operands +0.0 - -Infinity = Infinity, with float exprs operands +0.0 * -Infinity = NaN, with float exprs operands +0.0 / -Infinity = -0.0, with float exprs operands +-0.0 + Infinity = Infinity, with float param operands +-0.0 - Infinity = -Infinity, with float param operands +-0.0 * Infinity = NaN, with float param operands +-0.0 / Infinity = -0.0, with float param operands +-0.0 + Infinity = Infinity, with float local operands +-0.0 - Infinity = -Infinity, with float local operands +-0.0 * Infinity = NaN, with float local operands +-0.0 / Infinity = -0.0, with float local operands +-0.0 + Infinity = Infinity, with float static operands +-0.0 - Infinity = -Infinity, with float static operands +-0.0 * Infinity = NaN, with float static operands +-0.0 / Infinity = -0.0, with float static operands +-0.0 + Infinity = Infinity, with float field operands +-0.0 - Infinity = -Infinity, with float field operands +-0.0 * Infinity = NaN, with float field operands +-0.0 / Infinity = -0.0, with float field operands +-0.0 + Infinity = Infinity, with float a[i] operands +-0.0 - Infinity = -Infinity, with float a[i] operands +-0.0 * Infinity = NaN, with float a[i] operands +-0.0 / Infinity = -0.0, with float a[i] operands +-0.0 + Infinity = Infinity, with float f(x) operands +-0.0 - Infinity = -Infinity, with float f(x) operands +-0.0 * Infinity = NaN, with float f(x) operands +-0.0 / Infinity = -0.0, with float f(x) operands +0.0 + Infinity = Infinity, with float lExpr operands +0.0 - Infinity = -Infinity, with float lExpr operands +0.0 * Infinity = NaN, with float lExpr operands +0.0 / Infinity = 0.0, with float lExpr operands +-0.0 + Infinity = Infinity, with float rExpr operands +-0.0 - Infinity = -Infinity, with float rExpr operands +-0.0 * Infinity = NaN, with float rExpr operands +-0.0 / Infinity = -0.0, with float rExpr operands +0.0 + Infinity = Infinity, with float exprs operands +0.0 - Infinity = -Infinity, with float exprs operands +0.0 * Infinity = NaN, with float exprs operands +0.0 / Infinity = 0.0, with float exprs operands +-0.0 + NaN = NaN, with float param operands +-0.0 - NaN = NaN, with float param operands +-0.0 * NaN = NaN, with float param operands +-0.0 / NaN = NaN, with float param operands +-0.0 + NaN = NaN, with float local operands +-0.0 - NaN = NaN, with float local operands +-0.0 * NaN = NaN, with float local operands +-0.0 / NaN = NaN, with float local operands +-0.0 + NaN = NaN, with float static operands +-0.0 - NaN = NaN, with float static operands +-0.0 * NaN = NaN, with float static operands +-0.0 / NaN = NaN, with float static operands +-0.0 + NaN = NaN, with float field operands +-0.0 - NaN = NaN, with float field operands +-0.0 * NaN = NaN, with float field operands +-0.0 / NaN = NaN, with float field operands +-0.0 + NaN = NaN, with float a[i] operands +-0.0 - NaN = NaN, with float a[i] operands +-0.0 * NaN = NaN, with float a[i] operands +-0.0 / NaN = NaN, with float a[i] operands +-0.0 + NaN = NaN, with float f(x) operands +-0.0 - NaN = NaN, with float f(x) operands +-0.0 * NaN = NaN, with float f(x) operands +-0.0 / NaN = NaN, with float f(x) operands +0.0 + NaN = NaN, with float lExpr operands +0.0 - NaN = NaN, with float lExpr operands +0.0 * NaN = NaN, with float lExpr operands +0.0 / NaN = NaN, with float lExpr operands +-0.0 + NaN = NaN, with float rExpr operands +-0.0 - NaN = NaN, with float rExpr operands +-0.0 * NaN = NaN, with float rExpr operands +-0.0 / NaN = NaN, with float rExpr operands +0.0 + NaN = NaN, with float exprs operands +0.0 - NaN = NaN, with float exprs operands +0.0 * NaN = NaN, with float exprs operands +0.0 / NaN = NaN, with float exprs operands +0.0 + 1.4E-45 = 1.4E-45, with float param operands +0.0 - 1.4E-45 = -1.4E-45, with float param operands +0.0 * 1.4E-45 = 0.0, with float param operands +0.0 / 1.4E-45 = 0.0, with float param operands +0.0 + 1.4E-45 = 1.4E-45, with float local operands +0.0 - 1.4E-45 = -1.4E-45, with float local operands +0.0 * 1.4E-45 = 0.0, with float local operands +0.0 / 1.4E-45 = 0.0, with float local operands +0.0 + 1.4E-45 = 1.4E-45, with float static operands +0.0 - 1.4E-45 = -1.4E-45, with float static operands +0.0 * 1.4E-45 = 0.0, with float static operands +0.0 / 1.4E-45 = 0.0, with float static operands +0.0 + 1.4E-45 = 1.4E-45, with float field operands +0.0 - 1.4E-45 = -1.4E-45, with float field operands +0.0 * 1.4E-45 = 0.0, with float field operands +0.0 / 1.4E-45 = 0.0, with float field operands +0.0 + 1.4E-45 = 1.4E-45, with float a[i] operands +0.0 - 1.4E-45 = -1.4E-45, with float a[i] operands +0.0 * 1.4E-45 = 0.0, with float a[i] operands +0.0 / 1.4E-45 = 0.0, with float a[i] operands +0.0 + 1.4E-45 = 1.4E-45, with float f(x) operands +0.0 - 1.4E-45 = -1.4E-45, with float f(x) operands +0.0 * 1.4E-45 = 0.0, with float f(x) operands +0.0 / 1.4E-45 = 0.0, with float f(x) operands +0.0 + 1.4E-45 = 1.4E-45, with float lExpr operands +0.0 - 1.4E-45 = -1.4E-45, with float lExpr operands +0.0 * 1.4E-45 = 0.0, with float lExpr operands +0.0 / 1.4E-45 = 0.0, with float lExpr operands +0.0 + 1.4E-45 = 1.4E-45, with float rExpr operands +0.0 - 1.4E-45 = -1.4E-45, with float rExpr operands +0.0 * 1.4E-45 = 0.0, with float rExpr operands +0.0 / 1.4E-45 = 0.0, with float rExpr operands +0.0 + 1.4E-45 = 1.4E-45, with float exprs operands +0.0 - 1.4E-45 = -1.4E-45, with float exprs operands +0.0 * 1.4E-45 = 0.0, with float exprs operands +0.0 / 1.4E-45 = 0.0, with float exprs operands +0.0 + 3.4028235E38 = 3.4028235E38, with float param operands +0.0 - 3.4028235E38 = -3.4028235E38, with float param operands +0.0 * 3.4028235E38 = 0.0, with float param operands +0.0 / 3.4028235E38 = 0.0, with float param operands +0.0 + 3.4028235E38 = 3.4028235E38, with float local operands +0.0 - 3.4028235E38 = -3.4028235E38, with float local operands +0.0 * 3.4028235E38 = 0.0, with float local operands +0.0 / 3.4028235E38 = 0.0, with float local operands +0.0 + 3.4028235E38 = 3.4028235E38, with float static operands +0.0 - 3.4028235E38 = -3.4028235E38, with float static operands +0.0 * 3.4028235E38 = 0.0, with float static operands +0.0 / 3.4028235E38 = 0.0, with float static operands +0.0 + 3.4028235E38 = 3.4028235E38, with float field operands +0.0 - 3.4028235E38 = -3.4028235E38, with float field operands +0.0 * 3.4028235E38 = 0.0, with float field operands +0.0 / 3.4028235E38 = 0.0, with float field operands +0.0 + 3.4028235E38 = 3.4028235E38, with float a[i] operands +0.0 - 3.4028235E38 = -3.4028235E38, with float a[i] operands +0.0 * 3.4028235E38 = 0.0, with float a[i] operands +0.0 / 3.4028235E38 = 0.0, with float a[i] operands +0.0 + 3.4028235E38 = 3.4028235E38, with float f(x) operands +0.0 - 3.4028235E38 = -3.4028235E38, with float f(x) operands +0.0 * 3.4028235E38 = 0.0, with float f(x) operands +0.0 / 3.4028235E38 = 0.0, with float f(x) operands +0.0 + 3.4028235E38 = 3.4028235E38, with float lExpr operands +0.0 - 3.4028235E38 = -3.4028235E38, with float lExpr operands +0.0 * 3.4028235E38 = 0.0, with float lExpr operands +0.0 / 3.4028235E38 = 0.0, with float lExpr operands +0.0 + 3.4028235E38 = 3.4028235E38, with float rExpr operands +0.0 - 3.4028235E38 = -3.4028235E38, with float rExpr operands +0.0 * 3.4028235E38 = 0.0, with float rExpr operands +0.0 / 3.4028235E38 = 0.0, with float rExpr operands +0.0 + 3.4028235E38 = 3.4028235E38, with float exprs operands +0.0 - 3.4028235E38 = -3.4028235E38, with float exprs operands +0.0 * 3.4028235E38 = 0.0, with float exprs operands +0.0 / 3.4028235E38 = 0.0, with float exprs operands +0.0 + -1.4E-45 = -1.4E-45, with float param operands +0.0 - -1.4E-45 = 1.4E-45, with float param operands +0.0 * -1.4E-45 = -0.0, with float param operands +0.0 / -1.4E-45 = -0.0, with float param operands +0.0 + -1.4E-45 = -1.4E-45, with float local operands +0.0 - -1.4E-45 = 1.4E-45, with float local operands +0.0 * -1.4E-45 = -0.0, with float local operands +0.0 / -1.4E-45 = -0.0, with float local operands +0.0 + -1.4E-45 = -1.4E-45, with float static operands +0.0 - -1.4E-45 = 1.4E-45, with float static operands +0.0 * -1.4E-45 = -0.0, with float static operands +0.0 / -1.4E-45 = -0.0, with float static operands +0.0 + -1.4E-45 = -1.4E-45, with float field operands +0.0 - -1.4E-45 = 1.4E-45, with float field operands +0.0 * -1.4E-45 = -0.0, with float field operands +0.0 / -1.4E-45 = -0.0, with float field operands +0.0 + -1.4E-45 = -1.4E-45, with float a[i] operands +0.0 - -1.4E-45 = 1.4E-45, with float a[i] operands +0.0 * -1.4E-45 = -0.0, with float a[i] operands +0.0 / -1.4E-45 = -0.0, with float a[i] operands +0.0 + -1.4E-45 = -1.4E-45, with float f(x) operands +0.0 - -1.4E-45 = 1.4E-45, with float f(x) operands +0.0 * -1.4E-45 = -0.0, with float f(x) operands +0.0 / -1.4E-45 = -0.0, with float f(x) operands +0.0 + -1.4E-45 = -1.4E-45, with float lExpr operands +0.0 - -1.4E-45 = 1.4E-45, with float lExpr operands +0.0 * -1.4E-45 = -0.0, with float lExpr operands +0.0 / -1.4E-45 = -0.0, with float lExpr operands +0.0 + -1.4E-45 = -1.4E-45, with float rExpr operands +0.0 - -1.4E-45 = 1.4E-45, with float rExpr operands +0.0 * -1.4E-45 = -0.0, with float rExpr operands +0.0 / -1.4E-45 = -0.0, with float rExpr operands +0.0 + -1.4E-45 = -1.4E-45, with float exprs operands +0.0 - -1.4E-45 = 1.4E-45, with float exprs operands +0.0 * -1.4E-45 = -0.0, with float exprs operands +0.0 / -1.4E-45 = -0.0, with float exprs operands +0.0 + -3.4028235E38 = -3.4028235E38, with float param operands +0.0 - -3.4028235E38 = 3.4028235E38, with float param operands +0.0 * -3.4028235E38 = -0.0, with float param operands +0.0 / -3.4028235E38 = -0.0, with float param operands +0.0 + -3.4028235E38 = -3.4028235E38, with float local operands +0.0 - -3.4028235E38 = 3.4028235E38, with float local operands +0.0 * -3.4028235E38 = -0.0, with float local operands +0.0 / -3.4028235E38 = -0.0, with float local operands +0.0 + -3.4028235E38 = -3.4028235E38, with float static operands +0.0 - -3.4028235E38 = 3.4028235E38, with float static operands +0.0 * -3.4028235E38 = -0.0, with float static operands +0.0 / -3.4028235E38 = -0.0, with float static operands +0.0 + -3.4028235E38 = -3.4028235E38, with float field operands +0.0 - -3.4028235E38 = 3.4028235E38, with float field operands +0.0 * -3.4028235E38 = -0.0, with float field operands +0.0 / -3.4028235E38 = -0.0, with float field operands +0.0 + -3.4028235E38 = -3.4028235E38, with float a[i] operands +0.0 - -3.4028235E38 = 3.4028235E38, with float a[i] operands +0.0 * -3.4028235E38 = -0.0, with float a[i] operands +0.0 / -3.4028235E38 = -0.0, with float a[i] operands +0.0 + -3.4028235E38 = -3.4028235E38, with float f(x) operands +0.0 - -3.4028235E38 = 3.4028235E38, with float f(x) operands +0.0 * -3.4028235E38 = -0.0, with float f(x) operands +0.0 / -3.4028235E38 = -0.0, with float f(x) operands +0.0 + -3.4028235E38 = -3.4028235E38, with float lExpr operands +0.0 - -3.4028235E38 = 3.4028235E38, with float lExpr operands +0.0 * -3.4028235E38 = -0.0, with float lExpr operands +0.0 / -3.4028235E38 = -0.0, with float lExpr operands +0.0 + -3.4028235E38 = -3.4028235E38, with float rExpr operands +0.0 - -3.4028235E38 = 3.4028235E38, with float rExpr operands +0.0 * -3.4028235E38 = -0.0, with float rExpr operands +0.0 / -3.4028235E38 = -0.0, with float rExpr operands +0.0 + -3.4028235E38 = -3.4028235E38, with float exprs operands +0.0 - -3.4028235E38 = 3.4028235E38, with float exprs operands +0.0 * -3.4028235E38 = -0.0, with float exprs operands +0.0 / -3.4028235E38 = -0.0, with float exprs operands +0.0 + -1.0 = -1.0, with float param operands +0.0 - -1.0 = 1.0, with float param operands +0.0 * -1.0 = -0.0, with float param operands +0.0 / -1.0 = -0.0, with float param operands +0.0 + -1.0 = -1.0, with float local operands +0.0 - -1.0 = 1.0, with float local operands +0.0 * -1.0 = -0.0, with float local operands +0.0 / -1.0 = -0.0, with float local operands +0.0 + -1.0 = -1.0, with float static operands +0.0 - -1.0 = 1.0, with float static operands +0.0 * -1.0 = -0.0, with float static operands +0.0 / -1.0 = -0.0, with float static operands +0.0 + -1.0 = -1.0, with float field operands +0.0 - -1.0 = 1.0, with float field operands +0.0 * -1.0 = -0.0, with float field operands +0.0 / -1.0 = -0.0, with float field operands +0.0 + -1.0 = -1.0, with float a[i] operands +0.0 - -1.0 = 1.0, with float a[i] operands +0.0 * -1.0 = -0.0, with float a[i] operands +0.0 / -1.0 = -0.0, with float a[i] operands +0.0 + -1.0 = -1.0, with float f(x) operands +0.0 - -1.0 = 1.0, with float f(x) operands +0.0 * -1.0 = -0.0, with float f(x) operands +0.0 / -1.0 = -0.0, with float f(x) operands +0.0 + -1.0 = -1.0, with float lExpr operands +0.0 - -1.0 = 1.0, with float lExpr operands +0.0 * -1.0 = -0.0, with float lExpr operands +0.0 / -1.0 = -0.0, with float lExpr operands +0.0 + -1.0 = -1.0, with float rExpr operands +0.0 - -1.0 = 1.0, with float rExpr operands +0.0 * -1.0 = -0.0, with float rExpr operands +0.0 / -1.0 = -0.0, with float rExpr operands +0.0 + -1.0 = -1.0, with float exprs operands +0.0 - -1.0 = 1.0, with float exprs operands +0.0 * -1.0 = -0.0, with float exprs operands +0.0 / -1.0 = -0.0, with float exprs operands +0.0 + 1.0 = 1.0, with float param operands +0.0 - 1.0 = -1.0, with float param operands +0.0 * 1.0 = 0.0, with float param operands +0.0 / 1.0 = 0.0, with float param operands +0.0 + 1.0 = 1.0, with float local operands +0.0 - 1.0 = -1.0, with float local operands +0.0 * 1.0 = 0.0, with float local operands +0.0 / 1.0 = 0.0, with float local operands +0.0 + 1.0 = 1.0, with float static operands +0.0 - 1.0 = -1.0, with float static operands +0.0 * 1.0 = 0.0, with float static operands +0.0 / 1.0 = 0.0, with float static operands +0.0 + 1.0 = 1.0, with float field operands +0.0 - 1.0 = -1.0, with float field operands +0.0 * 1.0 = 0.0, with float field operands +0.0 / 1.0 = 0.0, with float field operands +0.0 + 1.0 = 1.0, with float a[i] operands +0.0 - 1.0 = -1.0, with float a[i] operands +0.0 * 1.0 = 0.0, with float a[i] operands +0.0 / 1.0 = 0.0, with float a[i] operands +0.0 + 1.0 = 1.0, with float f(x) operands +0.0 - 1.0 = -1.0, with float f(x) operands +0.0 * 1.0 = 0.0, with float f(x) operands +0.0 / 1.0 = 0.0, with float f(x) operands +0.0 + 1.0 = 1.0, with float lExpr operands +0.0 - 1.0 = -1.0, with float lExpr operands +0.0 * 1.0 = 0.0, with float lExpr operands +0.0 / 1.0 = 0.0, with float lExpr operands +0.0 + 1.0 = 1.0, with float rExpr operands +0.0 - 1.0 = -1.0, with float rExpr operands +0.0 * 1.0 = 0.0, with float rExpr operands +0.0 / 1.0 = 0.0, with float rExpr operands +0.0 + 1.0 = 1.0, with float exprs operands +0.0 - 1.0 = -1.0, with float exprs operands +0.0 * 1.0 = 0.0, with float exprs operands +0.0 / 1.0 = 0.0, with float exprs operands +0.0 + -0.0 = 0.0, with float param operands +0.0 - -0.0 = 0.0, with float param operands +0.0 * -0.0 = -0.0, with float param operands +0.0 / -0.0 = NaN, with float param operands +0.0 + -0.0 = 0.0, with float local operands +0.0 - -0.0 = 0.0, with float local operands +0.0 * -0.0 = -0.0, with float local operands +0.0 / -0.0 = NaN, with float local operands +0.0 + -0.0 = 0.0, with float static operands +0.0 - -0.0 = 0.0, with float static operands +0.0 * -0.0 = -0.0, with float static operands +0.0 / -0.0 = NaN, with float static operands +0.0 + -0.0 = 0.0, with float field operands +0.0 - -0.0 = 0.0, with float field operands +0.0 * -0.0 = -0.0, with float field operands +0.0 / -0.0 = NaN, with float field operands +0.0 + -0.0 = 0.0, with float a[i] operands +0.0 - -0.0 = 0.0, with float a[i] operands +0.0 * -0.0 = -0.0, with float a[i] operands +0.0 / -0.0 = NaN, with float a[i] operands +0.0 + -0.0 = 0.0, with float f(x) operands +0.0 - -0.0 = 0.0, with float f(x) operands +0.0 * -0.0 = -0.0, with float f(x) operands +0.0 / -0.0 = NaN, with float f(x) operands +0.0 + -0.0 = 0.0, with float lExpr operands +0.0 - -0.0 = 0.0, with float lExpr operands +0.0 * -0.0 = -0.0, with float lExpr operands +0.0 / -0.0 = NaN, with float lExpr operands +0.0 + 0.0 = 0.0, with float rExpr operands +0.0 - 0.0 = 0.0, with float rExpr operands +0.0 * 0.0 = 0.0, with float rExpr operands +0.0 / 0.0 = NaN, with float rExpr operands +0.0 + 0.0 = 0.0, with float exprs operands +0.0 - 0.0 = 0.0, with float exprs operands +0.0 * 0.0 = 0.0, with float exprs operands +0.0 / 0.0 = NaN, with float exprs operands +0.0 + 0.0 = 0.0, with float param operands +0.0 - 0.0 = 0.0, with float param operands +0.0 * 0.0 = 0.0, with float param operands +0.0 / 0.0 = NaN, with float param operands +0.0 + 0.0 = 0.0, with float local operands +0.0 - 0.0 = 0.0, with float local operands +0.0 * 0.0 = 0.0, with float local operands +0.0 / 0.0 = NaN, with float local operands +0.0 + 0.0 = 0.0, with float static operands +0.0 - 0.0 = 0.0, with float static operands +0.0 * 0.0 = 0.0, with float static operands +0.0 / 0.0 = NaN, with float static operands +0.0 + 0.0 = 0.0, with float field operands +0.0 - 0.0 = 0.0, with float field operands +0.0 * 0.0 = 0.0, with float field operands +0.0 / 0.0 = NaN, with float field operands +0.0 + 0.0 = 0.0, with float a[i] operands +0.0 - 0.0 = 0.0, with float a[i] operands +0.0 * 0.0 = 0.0, with float a[i] operands +0.0 / 0.0 = NaN, with float a[i] operands +0.0 + 0.0 = 0.0, with float f(x) operands +0.0 - 0.0 = 0.0, with float f(x) operands +0.0 * 0.0 = 0.0, with float f(x) operands +0.0 / 0.0 = NaN, with float f(x) operands +0.0 + 0.0 = 0.0, with float lExpr operands +0.0 - 0.0 = 0.0, with float lExpr operands +0.0 * 0.0 = 0.0, with float lExpr operands +0.0 / 0.0 = NaN, with float lExpr operands +0.0 + 0.0 = 0.0, with float rExpr operands +0.0 - 0.0 = 0.0, with float rExpr operands +0.0 * 0.0 = 0.0, with float rExpr operands +0.0 / 0.0 = NaN, with float rExpr operands +0.0 + 0.0 = 0.0, with float exprs operands +0.0 - 0.0 = 0.0, with float exprs operands +0.0 * 0.0 = 0.0, with float exprs operands +0.0 / 0.0 = NaN, with float exprs operands +0.0 + -Infinity = -Infinity, with float param operands +0.0 - -Infinity = Infinity, with float param operands +0.0 * -Infinity = NaN, with float param operands +0.0 / -Infinity = -0.0, with float param operands +0.0 + -Infinity = -Infinity, with float local operands +0.0 - -Infinity = Infinity, with float local operands +0.0 * -Infinity = NaN, with float local operands +0.0 / -Infinity = -0.0, with float local operands +0.0 + -Infinity = -Infinity, with float static operands +0.0 - -Infinity = Infinity, with float static operands +0.0 * -Infinity = NaN, with float static operands +0.0 / -Infinity = -0.0, with float static operands +0.0 + -Infinity = -Infinity, with float field operands +0.0 - -Infinity = Infinity, with float field operands +0.0 * -Infinity = NaN, with float field operands +0.0 / -Infinity = -0.0, with float field operands +0.0 + -Infinity = -Infinity, with float a[i] operands +0.0 - -Infinity = Infinity, with float a[i] operands +0.0 * -Infinity = NaN, with float a[i] operands +0.0 / -Infinity = -0.0, with float a[i] operands +0.0 + -Infinity = -Infinity, with float f(x) operands +0.0 - -Infinity = Infinity, with float f(x) operands +0.0 * -Infinity = NaN, with float f(x) operands +0.0 / -Infinity = -0.0, with float f(x) operands +0.0 + -Infinity = -Infinity, with float lExpr operands +0.0 - -Infinity = Infinity, with float lExpr operands +0.0 * -Infinity = NaN, with float lExpr operands +0.0 / -Infinity = -0.0, with float lExpr operands +0.0 + -Infinity = -Infinity, with float rExpr operands +0.0 - -Infinity = Infinity, with float rExpr operands +0.0 * -Infinity = NaN, with float rExpr operands +0.0 / -Infinity = -0.0, with float rExpr operands +0.0 + -Infinity = -Infinity, with float exprs operands +0.0 - -Infinity = Infinity, with float exprs operands +0.0 * -Infinity = NaN, with float exprs operands +0.0 / -Infinity = -0.0, with float exprs operands +0.0 + Infinity = Infinity, with float param operands +0.0 - Infinity = -Infinity, with float param operands +0.0 * Infinity = NaN, with float param operands +0.0 / Infinity = 0.0, with float param operands +0.0 + Infinity = Infinity, with float local operands +0.0 - Infinity = -Infinity, with float local operands +0.0 * Infinity = NaN, with float local operands +0.0 / Infinity = 0.0, with float local operands +0.0 + Infinity = Infinity, with float static operands +0.0 - Infinity = -Infinity, with float static operands +0.0 * Infinity = NaN, with float static operands +0.0 / Infinity = 0.0, with float static operands +0.0 + Infinity = Infinity, with float field operands +0.0 - Infinity = -Infinity, with float field operands +0.0 * Infinity = NaN, with float field operands +0.0 / Infinity = 0.0, with float field operands +0.0 + Infinity = Infinity, with float a[i] operands +0.0 - Infinity = -Infinity, with float a[i] operands +0.0 * Infinity = NaN, with float a[i] operands +0.0 / Infinity = 0.0, with float a[i] operands +0.0 + Infinity = Infinity, with float f(x) operands +0.0 - Infinity = -Infinity, with float f(x) operands +0.0 * Infinity = NaN, with float f(x) operands +0.0 / Infinity = 0.0, with float f(x) operands +0.0 + Infinity = Infinity, with float lExpr operands +0.0 - Infinity = -Infinity, with float lExpr operands +0.0 * Infinity = NaN, with float lExpr operands +0.0 / Infinity = 0.0, with float lExpr operands +0.0 + Infinity = Infinity, with float rExpr operands +0.0 - Infinity = -Infinity, with float rExpr operands +0.0 * Infinity = NaN, with float rExpr operands +0.0 / Infinity = 0.0, with float rExpr operands +0.0 + Infinity = Infinity, with float exprs operands +0.0 - Infinity = -Infinity, with float exprs operands +0.0 * Infinity = NaN, with float exprs operands +0.0 / Infinity = 0.0, with float exprs operands +0.0 + NaN = NaN, with float param operands +0.0 - NaN = NaN, with float param operands +0.0 * NaN = NaN, with float param operands +0.0 / NaN = NaN, with float param operands +0.0 + NaN = NaN, with float local operands +0.0 - NaN = NaN, with float local operands +0.0 * NaN = NaN, with float local operands +0.0 / NaN = NaN, with float local operands +0.0 + NaN = NaN, with float static operands +0.0 - NaN = NaN, with float static operands +0.0 * NaN = NaN, with float static operands +0.0 / NaN = NaN, with float static operands +0.0 + NaN = NaN, with float field operands +0.0 - NaN = NaN, with float field operands +0.0 * NaN = NaN, with float field operands +0.0 / NaN = NaN, with float field operands +0.0 + NaN = NaN, with float a[i] operands +0.0 - NaN = NaN, with float a[i] operands +0.0 * NaN = NaN, with float a[i] operands +0.0 / NaN = NaN, with float a[i] operands +0.0 + NaN = NaN, with float f(x) operands +0.0 - NaN = NaN, with float f(x) operands +0.0 * NaN = NaN, with float f(x) operands +0.0 / NaN = NaN, with float f(x) operands +0.0 + NaN = NaN, with float lExpr operands +0.0 - NaN = NaN, with float lExpr operands +0.0 * NaN = NaN, with float lExpr operands +0.0 / NaN = NaN, with float lExpr operands +0.0 + NaN = NaN, with float rExpr operands +0.0 - NaN = NaN, with float rExpr operands +0.0 * NaN = NaN, with float rExpr operands +0.0 / NaN = NaN, with float rExpr operands +0.0 + NaN = NaN, with float exprs operands +0.0 - NaN = NaN, with float exprs operands +0.0 * NaN = NaN, with float exprs operands +0.0 / NaN = NaN, with float exprs operands +-Infinity + 1.4E-45 = -Infinity, with float param operands +-Infinity - 1.4E-45 = -Infinity, with float param operands +-Infinity * 1.4E-45 = -Infinity, with float param operands +-Infinity / 1.4E-45 = -Infinity, with float param operands +-Infinity + 1.4E-45 = -Infinity, with float local operands +-Infinity - 1.4E-45 = -Infinity, with float local operands +-Infinity * 1.4E-45 = -Infinity, with float local operands +-Infinity / 1.4E-45 = -Infinity, with float local operands +-Infinity + 1.4E-45 = -Infinity, with float static operands +-Infinity - 1.4E-45 = -Infinity, with float static operands +-Infinity * 1.4E-45 = -Infinity, with float static operands +-Infinity / 1.4E-45 = -Infinity, with float static operands +-Infinity + 1.4E-45 = -Infinity, with float field operands +-Infinity - 1.4E-45 = -Infinity, with float field operands +-Infinity * 1.4E-45 = -Infinity, with float field operands +-Infinity / 1.4E-45 = -Infinity, with float field operands +-Infinity + 1.4E-45 = -Infinity, with float a[i] operands +-Infinity - 1.4E-45 = -Infinity, with float a[i] operands +-Infinity * 1.4E-45 = -Infinity, with float a[i] operands +-Infinity / 1.4E-45 = -Infinity, with float a[i] operands +-Infinity + 1.4E-45 = -Infinity, with float f(x) operands +-Infinity - 1.4E-45 = -Infinity, with float f(x) operands +-Infinity * 1.4E-45 = -Infinity, with float f(x) operands +-Infinity / 1.4E-45 = -Infinity, with float f(x) operands +-Infinity + 1.4E-45 = -Infinity, with float lExpr operands +-Infinity - 1.4E-45 = -Infinity, with float lExpr operands +-Infinity * 1.4E-45 = -Infinity, with float lExpr operands +-Infinity / 1.4E-45 = -Infinity, with float lExpr operands +-Infinity + 1.4E-45 = -Infinity, with float rExpr operands +-Infinity - 1.4E-45 = -Infinity, with float rExpr operands +-Infinity * 1.4E-45 = -Infinity, with float rExpr operands +-Infinity / 1.4E-45 = -Infinity, with float rExpr operands +-Infinity + 1.4E-45 = -Infinity, with float exprs operands +-Infinity - 1.4E-45 = -Infinity, with float exprs operands +-Infinity * 1.4E-45 = -Infinity, with float exprs operands +-Infinity / 1.4E-45 = -Infinity, with float exprs operands +-Infinity + 3.4028235E38 = -Infinity, with float param operands +-Infinity - 3.4028235E38 = -Infinity, with float param operands +-Infinity * 3.4028235E38 = -Infinity, with float param operands +-Infinity / 3.4028235E38 = -Infinity, with float param operands +-Infinity + 3.4028235E38 = -Infinity, with float local operands +-Infinity - 3.4028235E38 = -Infinity, with float local operands +-Infinity * 3.4028235E38 = -Infinity, with float local operands +-Infinity / 3.4028235E38 = -Infinity, with float local operands +-Infinity + 3.4028235E38 = -Infinity, with float static operands +-Infinity - 3.4028235E38 = -Infinity, with float static operands +-Infinity * 3.4028235E38 = -Infinity, with float static operands +-Infinity / 3.4028235E38 = -Infinity, with float static operands +-Infinity + 3.4028235E38 = -Infinity, with float field operands +-Infinity - 3.4028235E38 = -Infinity, with float field operands +-Infinity * 3.4028235E38 = -Infinity, with float field operands +-Infinity / 3.4028235E38 = -Infinity, with float field operands +-Infinity + 3.4028235E38 = -Infinity, with float a[i] operands +-Infinity - 3.4028235E38 = -Infinity, with float a[i] operands +-Infinity * 3.4028235E38 = -Infinity, with float a[i] operands +-Infinity / 3.4028235E38 = -Infinity, with float a[i] operands +-Infinity + 3.4028235E38 = -Infinity, with float f(x) operands +-Infinity - 3.4028235E38 = -Infinity, with float f(x) operands +-Infinity * 3.4028235E38 = -Infinity, with float f(x) operands +-Infinity / 3.4028235E38 = -Infinity, with float f(x) operands +-Infinity + 3.4028235E38 = -Infinity, with float lExpr operands +-Infinity - 3.4028235E38 = -Infinity, with float lExpr operands +-Infinity * 3.4028235E38 = -Infinity, with float lExpr operands +-Infinity / 3.4028235E38 = -Infinity, with float lExpr operands +-Infinity + 3.4028235E38 = -Infinity, with float rExpr operands +-Infinity - 3.4028235E38 = -Infinity, with float rExpr operands +-Infinity * 3.4028235E38 = -Infinity, with float rExpr operands +-Infinity / 3.4028235E38 = -Infinity, with float rExpr operands +-Infinity + 3.4028235E38 = -Infinity, with float exprs operands +-Infinity - 3.4028235E38 = -Infinity, with float exprs operands +-Infinity * 3.4028235E38 = -Infinity, with float exprs operands +-Infinity / 3.4028235E38 = -Infinity, with float exprs operands +-Infinity + -1.4E-45 = -Infinity, with float param operands +-Infinity - -1.4E-45 = -Infinity, with float param operands +-Infinity * -1.4E-45 = Infinity, with float param operands +-Infinity / -1.4E-45 = Infinity, with float param operands +-Infinity + -1.4E-45 = -Infinity, with float local operands +-Infinity - -1.4E-45 = -Infinity, with float local operands +-Infinity * -1.4E-45 = Infinity, with float local operands +-Infinity / -1.4E-45 = Infinity, with float local operands +-Infinity + -1.4E-45 = -Infinity, with float static operands +-Infinity - -1.4E-45 = -Infinity, with float static operands +-Infinity * -1.4E-45 = Infinity, with float static operands +-Infinity / -1.4E-45 = Infinity, with float static operands +-Infinity + -1.4E-45 = -Infinity, with float field operands +-Infinity - -1.4E-45 = -Infinity, with float field operands +-Infinity * -1.4E-45 = Infinity, with float field operands +-Infinity / -1.4E-45 = Infinity, with float field operands +-Infinity + -1.4E-45 = -Infinity, with float a[i] operands +-Infinity - -1.4E-45 = -Infinity, with float a[i] operands +-Infinity * -1.4E-45 = Infinity, with float a[i] operands +-Infinity / -1.4E-45 = Infinity, with float a[i] operands +-Infinity + -1.4E-45 = -Infinity, with float f(x) operands +-Infinity - -1.4E-45 = -Infinity, with float f(x) operands +-Infinity * -1.4E-45 = Infinity, with float f(x) operands +-Infinity / -1.4E-45 = Infinity, with float f(x) operands +-Infinity + -1.4E-45 = -Infinity, with float lExpr operands +-Infinity - -1.4E-45 = -Infinity, with float lExpr operands +-Infinity * -1.4E-45 = Infinity, with float lExpr operands +-Infinity / -1.4E-45 = Infinity, with float lExpr operands +-Infinity + -1.4E-45 = -Infinity, with float rExpr operands +-Infinity - -1.4E-45 = -Infinity, with float rExpr operands +-Infinity * -1.4E-45 = Infinity, with float rExpr operands +-Infinity / -1.4E-45 = Infinity, with float rExpr operands +-Infinity + -1.4E-45 = -Infinity, with float exprs operands +-Infinity - -1.4E-45 = -Infinity, with float exprs operands +-Infinity * -1.4E-45 = Infinity, with float exprs operands +-Infinity / -1.4E-45 = Infinity, with float exprs operands +-Infinity + -3.4028235E38 = -Infinity, with float param operands +-Infinity - -3.4028235E38 = -Infinity, with float param operands +-Infinity * -3.4028235E38 = Infinity, with float param operands +-Infinity / -3.4028235E38 = Infinity, with float param operands +-Infinity + -3.4028235E38 = -Infinity, with float local operands +-Infinity - -3.4028235E38 = -Infinity, with float local operands +-Infinity * -3.4028235E38 = Infinity, with float local operands +-Infinity / -3.4028235E38 = Infinity, with float local operands +-Infinity + -3.4028235E38 = -Infinity, with float static operands +-Infinity - -3.4028235E38 = -Infinity, with float static operands +-Infinity * -3.4028235E38 = Infinity, with float static operands +-Infinity / -3.4028235E38 = Infinity, with float static operands +-Infinity + -3.4028235E38 = -Infinity, with float field operands +-Infinity - -3.4028235E38 = -Infinity, with float field operands +-Infinity * -3.4028235E38 = Infinity, with float field operands +-Infinity / -3.4028235E38 = Infinity, with float field operands +-Infinity + -3.4028235E38 = -Infinity, with float a[i] operands +-Infinity - -3.4028235E38 = -Infinity, with float a[i] operands +-Infinity * -3.4028235E38 = Infinity, with float a[i] operands +-Infinity / -3.4028235E38 = Infinity, with float a[i] operands +-Infinity + -3.4028235E38 = -Infinity, with float f(x) operands +-Infinity - -3.4028235E38 = -Infinity, with float f(x) operands +-Infinity * -3.4028235E38 = Infinity, with float f(x) operands +-Infinity / -3.4028235E38 = Infinity, with float f(x) operands +-Infinity + -3.4028235E38 = -Infinity, with float lExpr operands +-Infinity - -3.4028235E38 = -Infinity, with float lExpr operands +-Infinity * -3.4028235E38 = Infinity, with float lExpr operands +-Infinity / -3.4028235E38 = Infinity, with float lExpr operands +-Infinity + -3.4028235E38 = -Infinity, with float rExpr operands +-Infinity - -3.4028235E38 = -Infinity, with float rExpr operands +-Infinity * -3.4028235E38 = Infinity, with float rExpr operands +-Infinity / -3.4028235E38 = Infinity, with float rExpr operands +-Infinity + -3.4028235E38 = -Infinity, with float exprs operands +-Infinity - -3.4028235E38 = -Infinity, with float exprs operands +-Infinity * -3.4028235E38 = Infinity, with float exprs operands +-Infinity / -3.4028235E38 = Infinity, with float exprs operands +-Infinity + -1.0 = -Infinity, with float param operands +-Infinity - -1.0 = -Infinity, with float param operands +-Infinity * -1.0 = Infinity, with float param operands +-Infinity / -1.0 = Infinity, with float param operands +-Infinity + -1.0 = -Infinity, with float local operands +-Infinity - -1.0 = -Infinity, with float local operands +-Infinity * -1.0 = Infinity, with float local operands +-Infinity / -1.0 = Infinity, with float local operands +-Infinity + -1.0 = -Infinity, with float static operands +-Infinity - -1.0 = -Infinity, with float static operands +-Infinity * -1.0 = Infinity, with float static operands +-Infinity / -1.0 = Infinity, with float static operands +-Infinity + -1.0 = -Infinity, with float field operands +-Infinity - -1.0 = -Infinity, with float field operands +-Infinity * -1.0 = Infinity, with float field operands +-Infinity / -1.0 = Infinity, with float field operands +-Infinity + -1.0 = -Infinity, with float a[i] operands +-Infinity - -1.0 = -Infinity, with float a[i] operands +-Infinity * -1.0 = Infinity, with float a[i] operands +-Infinity / -1.0 = Infinity, with float a[i] operands +-Infinity + -1.0 = -Infinity, with float f(x) operands +-Infinity - -1.0 = -Infinity, with float f(x) operands +-Infinity * -1.0 = Infinity, with float f(x) operands +-Infinity / -1.0 = Infinity, with float f(x) operands +-Infinity + -1.0 = -Infinity, with float lExpr operands +-Infinity - -1.0 = -Infinity, with float lExpr operands +-Infinity * -1.0 = Infinity, with float lExpr operands +-Infinity / -1.0 = Infinity, with float lExpr operands +-Infinity + -1.0 = -Infinity, with float rExpr operands +-Infinity - -1.0 = -Infinity, with float rExpr operands +-Infinity * -1.0 = Infinity, with float rExpr operands +-Infinity / -1.0 = Infinity, with float rExpr operands +-Infinity + -1.0 = -Infinity, with float exprs operands +-Infinity - -1.0 = -Infinity, with float exprs operands +-Infinity * -1.0 = Infinity, with float exprs operands +-Infinity / -1.0 = Infinity, with float exprs operands +-Infinity + 1.0 = -Infinity, with float param operands +-Infinity - 1.0 = -Infinity, with float param operands +-Infinity * 1.0 = -Infinity, with float param operands +-Infinity / 1.0 = -Infinity, with float param operands +-Infinity + 1.0 = -Infinity, with float local operands +-Infinity - 1.0 = -Infinity, with float local operands +-Infinity * 1.0 = -Infinity, with float local operands +-Infinity / 1.0 = -Infinity, with float local operands +-Infinity + 1.0 = -Infinity, with float static operands +-Infinity - 1.0 = -Infinity, with float static operands +-Infinity * 1.0 = -Infinity, with float static operands +-Infinity / 1.0 = -Infinity, with float static operands +-Infinity + 1.0 = -Infinity, with float field operands +-Infinity - 1.0 = -Infinity, with float field operands +-Infinity * 1.0 = -Infinity, with float field operands +-Infinity / 1.0 = -Infinity, with float field operands +-Infinity + 1.0 = -Infinity, with float a[i] operands +-Infinity - 1.0 = -Infinity, with float a[i] operands +-Infinity * 1.0 = -Infinity, with float a[i] operands +-Infinity / 1.0 = -Infinity, with float a[i] operands +-Infinity + 1.0 = -Infinity, with float f(x) operands +-Infinity - 1.0 = -Infinity, with float f(x) operands +-Infinity * 1.0 = -Infinity, with float f(x) operands +-Infinity / 1.0 = -Infinity, with float f(x) operands +-Infinity + 1.0 = -Infinity, with float lExpr operands +-Infinity - 1.0 = -Infinity, with float lExpr operands +-Infinity * 1.0 = -Infinity, with float lExpr operands +-Infinity / 1.0 = -Infinity, with float lExpr operands +-Infinity + 1.0 = -Infinity, with float rExpr operands +-Infinity - 1.0 = -Infinity, with float rExpr operands +-Infinity * 1.0 = -Infinity, with float rExpr operands +-Infinity / 1.0 = -Infinity, with float rExpr operands +-Infinity + 1.0 = -Infinity, with float exprs operands +-Infinity - 1.0 = -Infinity, with float exprs operands +-Infinity * 1.0 = -Infinity, with float exprs operands +-Infinity / 1.0 = -Infinity, with float exprs operands +-Infinity + -0.0 = -Infinity, with float param operands +-Infinity - -0.0 = -Infinity, with float param operands +-Infinity * -0.0 = NaN, with float param operands +-Infinity / -0.0 = Infinity, with float param operands +-Infinity + -0.0 = -Infinity, with float local operands +-Infinity - -0.0 = -Infinity, with float local operands +-Infinity * -0.0 = NaN, with float local operands +-Infinity / -0.0 = Infinity, with float local operands +-Infinity + -0.0 = -Infinity, with float static operands +-Infinity - -0.0 = -Infinity, with float static operands +-Infinity * -0.0 = NaN, with float static operands +-Infinity / -0.0 = Infinity, with float static operands +-Infinity + -0.0 = -Infinity, with float field operands +-Infinity - -0.0 = -Infinity, with float field operands +-Infinity * -0.0 = NaN, with float field operands +-Infinity / -0.0 = Infinity, with float field operands +-Infinity + -0.0 = -Infinity, with float a[i] operands +-Infinity - -0.0 = -Infinity, with float a[i] operands +-Infinity * -0.0 = NaN, with float a[i] operands +-Infinity / -0.0 = Infinity, with float a[i] operands +-Infinity + -0.0 = -Infinity, with float f(x) operands +-Infinity - -0.0 = -Infinity, with float f(x) operands +-Infinity * -0.0 = NaN, with float f(x) operands +-Infinity / -0.0 = Infinity, with float f(x) operands +-Infinity + -0.0 = -Infinity, with float lExpr operands +-Infinity - -0.0 = -Infinity, with float lExpr operands +-Infinity * -0.0 = NaN, with float lExpr operands +-Infinity / -0.0 = Infinity, with float lExpr operands +-Infinity + 0.0 = -Infinity, with float rExpr operands +-Infinity - 0.0 = -Infinity, with float rExpr operands +-Infinity * 0.0 = NaN, with float rExpr operands +-Infinity / 0.0 = -Infinity, with float rExpr operands +-Infinity + 0.0 = -Infinity, with float exprs operands +-Infinity - 0.0 = -Infinity, with float exprs operands +-Infinity * 0.0 = NaN, with float exprs operands +-Infinity / 0.0 = -Infinity, with float exprs operands +-Infinity + 0.0 = -Infinity, with float param operands +-Infinity - 0.0 = -Infinity, with float param operands +-Infinity * 0.0 = NaN, with float param operands +-Infinity / 0.0 = -Infinity, with float param operands +-Infinity + 0.0 = -Infinity, with float local operands +-Infinity - 0.0 = -Infinity, with float local operands +-Infinity * 0.0 = NaN, with float local operands +-Infinity / 0.0 = -Infinity, with float local operands +-Infinity + 0.0 = -Infinity, with float static operands +-Infinity - 0.0 = -Infinity, with float static operands +-Infinity * 0.0 = NaN, with float static operands +-Infinity / 0.0 = -Infinity, with float static operands +-Infinity + 0.0 = -Infinity, with float field operands +-Infinity - 0.0 = -Infinity, with float field operands +-Infinity * 0.0 = NaN, with float field operands +-Infinity / 0.0 = -Infinity, with float field operands +-Infinity + 0.0 = -Infinity, with float a[i] operands +-Infinity - 0.0 = -Infinity, with float a[i] operands +-Infinity * 0.0 = NaN, with float a[i] operands +-Infinity / 0.0 = -Infinity, with float a[i] operands +-Infinity + 0.0 = -Infinity, with float f(x) operands +-Infinity - 0.0 = -Infinity, with float f(x) operands +-Infinity * 0.0 = NaN, with float f(x) operands +-Infinity / 0.0 = -Infinity, with float f(x) operands +-Infinity + 0.0 = -Infinity, with float lExpr operands +-Infinity - 0.0 = -Infinity, with float lExpr operands +-Infinity * 0.0 = NaN, with float lExpr operands +-Infinity / 0.0 = -Infinity, with float lExpr operands +-Infinity + 0.0 = -Infinity, with float rExpr operands +-Infinity - 0.0 = -Infinity, with float rExpr operands +-Infinity * 0.0 = NaN, with float rExpr operands +-Infinity / 0.0 = -Infinity, with float rExpr operands +-Infinity + 0.0 = -Infinity, with float exprs operands +-Infinity - 0.0 = -Infinity, with float exprs operands +-Infinity * 0.0 = NaN, with float exprs operands +-Infinity / 0.0 = -Infinity, with float exprs operands +-Infinity + -Infinity = -Infinity, with float param operands +-Infinity - -Infinity = NaN, with float param operands +-Infinity * -Infinity = Infinity, with float param operands +-Infinity / -Infinity = NaN, with float param operands +-Infinity + -Infinity = -Infinity, with float local operands +-Infinity - -Infinity = NaN, with float local operands +-Infinity * -Infinity = Infinity, with float local operands +-Infinity / -Infinity = NaN, with float local operands +-Infinity + -Infinity = -Infinity, with float static operands +-Infinity - -Infinity = NaN, with float static operands +-Infinity * -Infinity = Infinity, with float static operands +-Infinity / -Infinity = NaN, with float static operands +-Infinity + -Infinity = -Infinity, with float field operands +-Infinity - -Infinity = NaN, with float field operands +-Infinity * -Infinity = Infinity, with float field operands +-Infinity / -Infinity = NaN, with float field operands +-Infinity + -Infinity = -Infinity, with float a[i] operands +-Infinity - -Infinity = NaN, with float a[i] operands +-Infinity * -Infinity = Infinity, with float a[i] operands +-Infinity / -Infinity = NaN, with float a[i] operands +-Infinity + -Infinity = -Infinity, with float f(x) operands +-Infinity - -Infinity = NaN, with float f(x) operands +-Infinity * -Infinity = Infinity, with float f(x) operands +-Infinity / -Infinity = NaN, with float f(x) operands +-Infinity + -Infinity = -Infinity, with float lExpr operands +-Infinity - -Infinity = NaN, with float lExpr operands +-Infinity * -Infinity = Infinity, with float lExpr operands +-Infinity / -Infinity = NaN, with float lExpr operands +-Infinity + -Infinity = -Infinity, with float rExpr operands +-Infinity - -Infinity = NaN, with float rExpr operands +-Infinity * -Infinity = Infinity, with float rExpr operands +-Infinity / -Infinity = NaN, with float rExpr operands +-Infinity + -Infinity = -Infinity, with float exprs operands +-Infinity - -Infinity = NaN, with float exprs operands +-Infinity * -Infinity = Infinity, with float exprs operands +-Infinity / -Infinity = NaN, with float exprs operands +-Infinity + Infinity = NaN, with float param operands +-Infinity - Infinity = -Infinity, with float param operands +-Infinity * Infinity = -Infinity, with float param operands +-Infinity / Infinity = NaN, with float param operands +-Infinity + Infinity = NaN, with float local operands +-Infinity - Infinity = -Infinity, with float local operands +-Infinity * Infinity = -Infinity, with float local operands +-Infinity / Infinity = NaN, with float local operands +-Infinity + Infinity = NaN, with float static operands +-Infinity - Infinity = -Infinity, with float static operands +-Infinity * Infinity = -Infinity, with float static operands +-Infinity / Infinity = NaN, with float static operands +-Infinity + Infinity = NaN, with float field operands +-Infinity - Infinity = -Infinity, with float field operands +-Infinity * Infinity = -Infinity, with float field operands +-Infinity / Infinity = NaN, with float field operands +-Infinity + Infinity = NaN, with float a[i] operands +-Infinity - Infinity = -Infinity, with float a[i] operands +-Infinity * Infinity = -Infinity, with float a[i] operands +-Infinity / Infinity = NaN, with float a[i] operands +-Infinity + Infinity = NaN, with float f(x) operands +-Infinity - Infinity = -Infinity, with float f(x) operands +-Infinity * Infinity = -Infinity, with float f(x) operands +-Infinity / Infinity = NaN, with float f(x) operands +-Infinity + Infinity = NaN, with float lExpr operands +-Infinity - Infinity = -Infinity, with float lExpr operands +-Infinity * Infinity = -Infinity, with float lExpr operands +-Infinity / Infinity = NaN, with float lExpr operands +-Infinity + Infinity = NaN, with float rExpr operands +-Infinity - Infinity = -Infinity, with float rExpr operands +-Infinity * Infinity = -Infinity, with float rExpr operands +-Infinity / Infinity = NaN, with float rExpr operands +-Infinity + Infinity = NaN, with float exprs operands +-Infinity - Infinity = -Infinity, with float exprs operands +-Infinity * Infinity = -Infinity, with float exprs operands +-Infinity / Infinity = NaN, with float exprs operands +-Infinity + NaN = NaN, with float param operands +-Infinity - NaN = NaN, with float param operands +-Infinity * NaN = NaN, with float param operands +-Infinity / NaN = NaN, with float param operands +-Infinity + NaN = NaN, with float local operands +-Infinity - NaN = NaN, with float local operands +-Infinity * NaN = NaN, with float local operands +-Infinity / NaN = NaN, with float local operands +-Infinity + NaN = NaN, with float static operands +-Infinity - NaN = NaN, with float static operands +-Infinity * NaN = NaN, with float static operands +-Infinity / NaN = NaN, with float static operands +-Infinity + NaN = NaN, with float field operands +-Infinity - NaN = NaN, with float field operands +-Infinity * NaN = NaN, with float field operands +-Infinity / NaN = NaN, with float field operands +-Infinity + NaN = NaN, with float a[i] operands +-Infinity - NaN = NaN, with float a[i] operands +-Infinity * NaN = NaN, with float a[i] operands +-Infinity / NaN = NaN, with float a[i] operands +-Infinity + NaN = NaN, with float f(x) operands +-Infinity - NaN = NaN, with float f(x) operands +-Infinity * NaN = NaN, with float f(x) operands +-Infinity / NaN = NaN, with float f(x) operands +-Infinity + NaN = NaN, with float lExpr operands +-Infinity - NaN = NaN, with float lExpr operands +-Infinity * NaN = NaN, with float lExpr operands +-Infinity / NaN = NaN, with float lExpr operands +-Infinity + NaN = NaN, with float rExpr operands +-Infinity - NaN = NaN, with float rExpr operands +-Infinity * NaN = NaN, with float rExpr operands +-Infinity / NaN = NaN, with float rExpr operands +-Infinity + NaN = NaN, with float exprs operands +-Infinity - NaN = NaN, with float exprs operands +-Infinity * NaN = NaN, with float exprs operands +-Infinity / NaN = NaN, with float exprs operands +Infinity + 1.4E-45 = Infinity, with float param operands +Infinity - 1.4E-45 = Infinity, with float param operands +Infinity * 1.4E-45 = Infinity, with float param operands +Infinity / 1.4E-45 = Infinity, with float param operands +Infinity + 1.4E-45 = Infinity, with float local operands +Infinity - 1.4E-45 = Infinity, with float local operands +Infinity * 1.4E-45 = Infinity, with float local operands +Infinity / 1.4E-45 = Infinity, with float local operands +Infinity + 1.4E-45 = Infinity, with float static operands +Infinity - 1.4E-45 = Infinity, with float static operands +Infinity * 1.4E-45 = Infinity, with float static operands +Infinity / 1.4E-45 = Infinity, with float static operands +Infinity + 1.4E-45 = Infinity, with float field operands +Infinity - 1.4E-45 = Infinity, with float field operands +Infinity * 1.4E-45 = Infinity, with float field operands +Infinity / 1.4E-45 = Infinity, with float field operands +Infinity + 1.4E-45 = Infinity, with float a[i] operands +Infinity - 1.4E-45 = Infinity, with float a[i] operands +Infinity * 1.4E-45 = Infinity, with float a[i] operands +Infinity / 1.4E-45 = Infinity, with float a[i] operands +Infinity + 1.4E-45 = Infinity, with float f(x) operands +Infinity - 1.4E-45 = Infinity, with float f(x) operands +Infinity * 1.4E-45 = Infinity, with float f(x) operands +Infinity / 1.4E-45 = Infinity, with float f(x) operands +Infinity + 1.4E-45 = Infinity, with float lExpr operands +Infinity - 1.4E-45 = Infinity, with float lExpr operands +Infinity * 1.4E-45 = Infinity, with float lExpr operands +Infinity / 1.4E-45 = Infinity, with float lExpr operands +Infinity + 1.4E-45 = Infinity, with float rExpr operands +Infinity - 1.4E-45 = Infinity, with float rExpr operands +Infinity * 1.4E-45 = Infinity, with float rExpr operands +Infinity / 1.4E-45 = Infinity, with float rExpr operands +Infinity + 1.4E-45 = Infinity, with float exprs operands +Infinity - 1.4E-45 = Infinity, with float exprs operands +Infinity * 1.4E-45 = Infinity, with float exprs operands +Infinity / 1.4E-45 = Infinity, with float exprs operands +Infinity + 3.4028235E38 = Infinity, with float param operands +Infinity - 3.4028235E38 = Infinity, with float param operands +Infinity * 3.4028235E38 = Infinity, with float param operands +Infinity / 3.4028235E38 = Infinity, with float param operands +Infinity + 3.4028235E38 = Infinity, with float local operands +Infinity - 3.4028235E38 = Infinity, with float local operands +Infinity * 3.4028235E38 = Infinity, with float local operands +Infinity / 3.4028235E38 = Infinity, with float local operands +Infinity + 3.4028235E38 = Infinity, with float static operands +Infinity - 3.4028235E38 = Infinity, with float static operands +Infinity * 3.4028235E38 = Infinity, with float static operands +Infinity / 3.4028235E38 = Infinity, with float static operands +Infinity + 3.4028235E38 = Infinity, with float field operands +Infinity - 3.4028235E38 = Infinity, with float field operands +Infinity * 3.4028235E38 = Infinity, with float field operands +Infinity / 3.4028235E38 = Infinity, with float field operands +Infinity + 3.4028235E38 = Infinity, with float a[i] operands +Infinity - 3.4028235E38 = Infinity, with float a[i] operands +Infinity * 3.4028235E38 = Infinity, with float a[i] operands +Infinity / 3.4028235E38 = Infinity, with float a[i] operands +Infinity + 3.4028235E38 = Infinity, with float f(x) operands +Infinity - 3.4028235E38 = Infinity, with float f(x) operands +Infinity * 3.4028235E38 = Infinity, with float f(x) operands +Infinity / 3.4028235E38 = Infinity, with float f(x) operands +Infinity + 3.4028235E38 = Infinity, with float lExpr operands +Infinity - 3.4028235E38 = Infinity, with float lExpr operands +Infinity * 3.4028235E38 = Infinity, with float lExpr operands +Infinity / 3.4028235E38 = Infinity, with float lExpr operands +Infinity + 3.4028235E38 = Infinity, with float rExpr operands +Infinity - 3.4028235E38 = Infinity, with float rExpr operands +Infinity * 3.4028235E38 = Infinity, with float rExpr operands +Infinity / 3.4028235E38 = Infinity, with float rExpr operands +Infinity + 3.4028235E38 = Infinity, with float exprs operands +Infinity - 3.4028235E38 = Infinity, with float exprs operands +Infinity * 3.4028235E38 = Infinity, with float exprs operands +Infinity / 3.4028235E38 = Infinity, with float exprs operands +Infinity + -1.4E-45 = Infinity, with float param operands +Infinity - -1.4E-45 = Infinity, with float param operands +Infinity * -1.4E-45 = -Infinity, with float param operands +Infinity / -1.4E-45 = -Infinity, with float param operands +Infinity + -1.4E-45 = Infinity, with float local operands +Infinity - -1.4E-45 = Infinity, with float local operands +Infinity * -1.4E-45 = -Infinity, with float local operands +Infinity / -1.4E-45 = -Infinity, with float local operands +Infinity + -1.4E-45 = Infinity, with float static operands +Infinity - -1.4E-45 = Infinity, with float static operands +Infinity * -1.4E-45 = -Infinity, with float static operands +Infinity / -1.4E-45 = -Infinity, with float static operands +Infinity + -1.4E-45 = Infinity, with float field operands +Infinity - -1.4E-45 = Infinity, with float field operands +Infinity * -1.4E-45 = -Infinity, with float field operands +Infinity / -1.4E-45 = -Infinity, with float field operands +Infinity + -1.4E-45 = Infinity, with float a[i] operands +Infinity - -1.4E-45 = Infinity, with float a[i] operands +Infinity * -1.4E-45 = -Infinity, with float a[i] operands +Infinity / -1.4E-45 = -Infinity, with float a[i] operands +Infinity + -1.4E-45 = Infinity, with float f(x) operands +Infinity - -1.4E-45 = Infinity, with float f(x) operands +Infinity * -1.4E-45 = -Infinity, with float f(x) operands +Infinity / -1.4E-45 = -Infinity, with float f(x) operands +Infinity + -1.4E-45 = Infinity, with float lExpr operands +Infinity - -1.4E-45 = Infinity, with float lExpr operands +Infinity * -1.4E-45 = -Infinity, with float lExpr operands +Infinity / -1.4E-45 = -Infinity, with float lExpr operands +Infinity + -1.4E-45 = Infinity, with float rExpr operands +Infinity - -1.4E-45 = Infinity, with float rExpr operands +Infinity * -1.4E-45 = -Infinity, with float rExpr operands +Infinity / -1.4E-45 = -Infinity, with float rExpr operands +Infinity + -1.4E-45 = Infinity, with float exprs operands +Infinity - -1.4E-45 = Infinity, with float exprs operands +Infinity * -1.4E-45 = -Infinity, with float exprs operands +Infinity / -1.4E-45 = -Infinity, with float exprs operands +Infinity + -3.4028235E38 = Infinity, with float param operands +Infinity - -3.4028235E38 = Infinity, with float param operands +Infinity * -3.4028235E38 = -Infinity, with float param operands +Infinity / -3.4028235E38 = -Infinity, with float param operands +Infinity + -3.4028235E38 = Infinity, with float local operands +Infinity - -3.4028235E38 = Infinity, with float local operands +Infinity * -3.4028235E38 = -Infinity, with float local operands +Infinity / -3.4028235E38 = -Infinity, with float local operands +Infinity + -3.4028235E38 = Infinity, with float static operands +Infinity - -3.4028235E38 = Infinity, with float static operands +Infinity * -3.4028235E38 = -Infinity, with float static operands +Infinity / -3.4028235E38 = -Infinity, with float static operands +Infinity + -3.4028235E38 = Infinity, with float field operands +Infinity - -3.4028235E38 = Infinity, with float field operands +Infinity * -3.4028235E38 = -Infinity, with float field operands +Infinity / -3.4028235E38 = -Infinity, with float field operands +Infinity + -3.4028235E38 = Infinity, with float a[i] operands +Infinity - -3.4028235E38 = Infinity, with float a[i] operands +Infinity * -3.4028235E38 = -Infinity, with float a[i] operands +Infinity / -3.4028235E38 = -Infinity, with float a[i] operands +Infinity + -3.4028235E38 = Infinity, with float f(x) operands +Infinity - -3.4028235E38 = Infinity, with float f(x) operands +Infinity * -3.4028235E38 = -Infinity, with float f(x) operands +Infinity / -3.4028235E38 = -Infinity, with float f(x) operands +Infinity + -3.4028235E38 = Infinity, with float lExpr operands +Infinity - -3.4028235E38 = Infinity, with float lExpr operands +Infinity * -3.4028235E38 = -Infinity, with float lExpr operands +Infinity / -3.4028235E38 = -Infinity, with float lExpr operands +Infinity + -3.4028235E38 = Infinity, with float rExpr operands +Infinity - -3.4028235E38 = Infinity, with float rExpr operands +Infinity * -3.4028235E38 = -Infinity, with float rExpr operands +Infinity / -3.4028235E38 = -Infinity, with float rExpr operands +Infinity + -3.4028235E38 = Infinity, with float exprs operands +Infinity - -3.4028235E38 = Infinity, with float exprs operands +Infinity * -3.4028235E38 = -Infinity, with float exprs operands +Infinity / -3.4028235E38 = -Infinity, with float exprs operands +Infinity + -1.0 = Infinity, with float param operands +Infinity - -1.0 = Infinity, with float param operands +Infinity * -1.0 = -Infinity, with float param operands +Infinity / -1.0 = -Infinity, with float param operands +Infinity + -1.0 = Infinity, with float local operands +Infinity - -1.0 = Infinity, with float local operands +Infinity * -1.0 = -Infinity, with float local operands +Infinity / -1.0 = -Infinity, with float local operands +Infinity + -1.0 = Infinity, with float static operands +Infinity - -1.0 = Infinity, with float static operands +Infinity * -1.0 = -Infinity, with float static operands +Infinity / -1.0 = -Infinity, with float static operands +Infinity + -1.0 = Infinity, with float field operands +Infinity - -1.0 = Infinity, with float field operands +Infinity * -1.0 = -Infinity, with float field operands +Infinity / -1.0 = -Infinity, with float field operands +Infinity + -1.0 = Infinity, with float a[i] operands +Infinity - -1.0 = Infinity, with float a[i] operands +Infinity * -1.0 = -Infinity, with float a[i] operands +Infinity / -1.0 = -Infinity, with float a[i] operands +Infinity + -1.0 = Infinity, with float f(x) operands +Infinity - -1.0 = Infinity, with float f(x) operands +Infinity * -1.0 = -Infinity, with float f(x) operands +Infinity / -1.0 = -Infinity, with float f(x) operands +Infinity + -1.0 = Infinity, with float lExpr operands +Infinity - -1.0 = Infinity, with float lExpr operands +Infinity * -1.0 = -Infinity, with float lExpr operands +Infinity / -1.0 = -Infinity, with float lExpr operands +Infinity + -1.0 = Infinity, with float rExpr operands +Infinity - -1.0 = Infinity, with float rExpr operands +Infinity * -1.0 = -Infinity, with float rExpr operands +Infinity / -1.0 = -Infinity, with float rExpr operands +Infinity + -1.0 = Infinity, with float exprs operands +Infinity - -1.0 = Infinity, with float exprs operands +Infinity * -1.0 = -Infinity, with float exprs operands +Infinity / -1.0 = -Infinity, with float exprs operands +Infinity + 1.0 = Infinity, with float param operands +Infinity - 1.0 = Infinity, with float param operands +Infinity * 1.0 = Infinity, with float param operands +Infinity / 1.0 = Infinity, with float param operands +Infinity + 1.0 = Infinity, with float local operands +Infinity - 1.0 = Infinity, with float local operands +Infinity * 1.0 = Infinity, with float local operands +Infinity / 1.0 = Infinity, with float local operands +Infinity + 1.0 = Infinity, with float static operands +Infinity - 1.0 = Infinity, with float static operands +Infinity * 1.0 = Infinity, with float static operands +Infinity / 1.0 = Infinity, with float static operands +Infinity + 1.0 = Infinity, with float field operands +Infinity - 1.0 = Infinity, with float field operands +Infinity * 1.0 = Infinity, with float field operands +Infinity / 1.0 = Infinity, with float field operands +Infinity + 1.0 = Infinity, with float a[i] operands +Infinity - 1.0 = Infinity, with float a[i] operands +Infinity * 1.0 = Infinity, with float a[i] operands +Infinity / 1.0 = Infinity, with float a[i] operands +Infinity + 1.0 = Infinity, with float f(x) operands +Infinity - 1.0 = Infinity, with float f(x) operands +Infinity * 1.0 = Infinity, with float f(x) operands +Infinity / 1.0 = Infinity, with float f(x) operands +Infinity + 1.0 = Infinity, with float lExpr operands +Infinity - 1.0 = Infinity, with float lExpr operands +Infinity * 1.0 = Infinity, with float lExpr operands +Infinity / 1.0 = Infinity, with float lExpr operands +Infinity + 1.0 = Infinity, with float rExpr operands +Infinity - 1.0 = Infinity, with float rExpr operands +Infinity * 1.0 = Infinity, with float rExpr operands +Infinity / 1.0 = Infinity, with float rExpr operands +Infinity + 1.0 = Infinity, with float exprs operands +Infinity - 1.0 = Infinity, with float exprs operands +Infinity * 1.0 = Infinity, with float exprs operands +Infinity / 1.0 = Infinity, with float exprs operands +Infinity + -0.0 = Infinity, with float param operands +Infinity - -0.0 = Infinity, with float param operands +Infinity * -0.0 = NaN, with float param operands +Infinity / -0.0 = -Infinity, with float param operands +Infinity + -0.0 = Infinity, with float local operands +Infinity - -0.0 = Infinity, with float local operands +Infinity * -0.0 = NaN, with float local operands +Infinity / -0.0 = -Infinity, with float local operands +Infinity + -0.0 = Infinity, with float static operands +Infinity - -0.0 = Infinity, with float static operands +Infinity * -0.0 = NaN, with float static operands +Infinity / -0.0 = -Infinity, with float static operands +Infinity + -0.0 = Infinity, with float field operands +Infinity - -0.0 = Infinity, with float field operands +Infinity * -0.0 = NaN, with float field operands +Infinity / -0.0 = -Infinity, with float field operands +Infinity + -0.0 = Infinity, with float a[i] operands +Infinity - -0.0 = Infinity, with float a[i] operands +Infinity * -0.0 = NaN, with float a[i] operands +Infinity / -0.0 = -Infinity, with float a[i] operands +Infinity + -0.0 = Infinity, with float f(x) operands +Infinity - -0.0 = Infinity, with float f(x) operands +Infinity * -0.0 = NaN, with float f(x) operands +Infinity / -0.0 = -Infinity, with float f(x) operands +Infinity + -0.0 = Infinity, with float lExpr operands +Infinity - -0.0 = Infinity, with float lExpr operands +Infinity * -0.0 = NaN, with float lExpr operands +Infinity / -0.0 = -Infinity, with float lExpr operands +Infinity + 0.0 = Infinity, with float rExpr operands +Infinity - 0.0 = Infinity, with float rExpr operands +Infinity * 0.0 = NaN, with float rExpr operands +Infinity / 0.0 = Infinity, with float rExpr operands +Infinity + 0.0 = Infinity, with float exprs operands +Infinity - 0.0 = Infinity, with float exprs operands +Infinity * 0.0 = NaN, with float exprs operands +Infinity / 0.0 = Infinity, with float exprs operands +Infinity + 0.0 = Infinity, with float param operands +Infinity - 0.0 = Infinity, with float param operands +Infinity * 0.0 = NaN, with float param operands +Infinity / 0.0 = Infinity, with float param operands +Infinity + 0.0 = Infinity, with float local operands +Infinity - 0.0 = Infinity, with float local operands +Infinity * 0.0 = NaN, with float local operands +Infinity / 0.0 = Infinity, with float local operands +Infinity + 0.0 = Infinity, with float static operands +Infinity - 0.0 = Infinity, with float static operands +Infinity * 0.0 = NaN, with float static operands +Infinity / 0.0 = Infinity, with float static operands +Infinity + 0.0 = Infinity, with float field operands +Infinity - 0.0 = Infinity, with float field operands +Infinity * 0.0 = NaN, with float field operands +Infinity / 0.0 = Infinity, with float field operands +Infinity + 0.0 = Infinity, with float a[i] operands +Infinity - 0.0 = Infinity, with float a[i] operands +Infinity * 0.0 = NaN, with float a[i] operands +Infinity / 0.0 = Infinity, with float a[i] operands +Infinity + 0.0 = Infinity, with float f(x) operands +Infinity - 0.0 = Infinity, with float f(x) operands +Infinity * 0.0 = NaN, with float f(x) operands +Infinity / 0.0 = Infinity, with float f(x) operands +Infinity + 0.0 = Infinity, with float lExpr operands +Infinity - 0.0 = Infinity, with float lExpr operands +Infinity * 0.0 = NaN, with float lExpr operands +Infinity / 0.0 = Infinity, with float lExpr operands +Infinity + 0.0 = Infinity, with float rExpr operands +Infinity - 0.0 = Infinity, with float rExpr operands +Infinity * 0.0 = NaN, with float rExpr operands +Infinity / 0.0 = Infinity, with float rExpr operands +Infinity + 0.0 = Infinity, with float exprs operands +Infinity - 0.0 = Infinity, with float exprs operands +Infinity * 0.0 = NaN, with float exprs operands +Infinity / 0.0 = Infinity, with float exprs operands +Infinity + -Infinity = NaN, with float param operands +Infinity - -Infinity = Infinity, with float param operands +Infinity * -Infinity = -Infinity, with float param operands +Infinity / -Infinity = NaN, with float param operands +Infinity + -Infinity = NaN, with float local operands +Infinity - -Infinity = Infinity, with float local operands +Infinity * -Infinity = -Infinity, with float local operands +Infinity / -Infinity = NaN, with float local operands +Infinity + -Infinity = NaN, with float static operands +Infinity - -Infinity = Infinity, with float static operands +Infinity * -Infinity = -Infinity, with float static operands +Infinity / -Infinity = NaN, with float static operands +Infinity + -Infinity = NaN, with float field operands +Infinity - -Infinity = Infinity, with float field operands +Infinity * -Infinity = -Infinity, with float field operands +Infinity / -Infinity = NaN, with float field operands +Infinity + -Infinity = NaN, with float a[i] operands +Infinity - -Infinity = Infinity, with float a[i] operands +Infinity * -Infinity = -Infinity, with float a[i] operands +Infinity / -Infinity = NaN, with float a[i] operands +Infinity + -Infinity = NaN, with float f(x) operands +Infinity - -Infinity = Infinity, with float f(x) operands +Infinity * -Infinity = -Infinity, with float f(x) operands +Infinity / -Infinity = NaN, with float f(x) operands +Infinity + -Infinity = NaN, with float lExpr operands +Infinity - -Infinity = Infinity, with float lExpr operands +Infinity * -Infinity = -Infinity, with float lExpr operands +Infinity / -Infinity = NaN, with float lExpr operands +Infinity + -Infinity = NaN, with float rExpr operands +Infinity - -Infinity = Infinity, with float rExpr operands +Infinity * -Infinity = -Infinity, with float rExpr operands +Infinity / -Infinity = NaN, with float rExpr operands +Infinity + -Infinity = NaN, with float exprs operands +Infinity - -Infinity = Infinity, with float exprs operands +Infinity * -Infinity = -Infinity, with float exprs operands +Infinity / -Infinity = NaN, with float exprs operands +Infinity + Infinity = Infinity, with float param operands +Infinity - Infinity = NaN, with float param operands +Infinity * Infinity = Infinity, with float param operands +Infinity / Infinity = NaN, with float param operands +Infinity + Infinity = Infinity, with float local operands +Infinity - Infinity = NaN, with float local operands +Infinity * Infinity = Infinity, with float local operands +Infinity / Infinity = NaN, with float local operands +Infinity + Infinity = Infinity, with float static operands +Infinity - Infinity = NaN, with float static operands +Infinity * Infinity = Infinity, with float static operands +Infinity / Infinity = NaN, with float static operands +Infinity + Infinity = Infinity, with float field operands +Infinity - Infinity = NaN, with float field operands +Infinity * Infinity = Infinity, with float field operands +Infinity / Infinity = NaN, with float field operands +Infinity + Infinity = Infinity, with float a[i] operands +Infinity - Infinity = NaN, with float a[i] operands +Infinity * Infinity = Infinity, with float a[i] operands +Infinity / Infinity = NaN, with float a[i] operands +Infinity + Infinity = Infinity, with float f(x) operands +Infinity - Infinity = NaN, with float f(x) operands +Infinity * Infinity = Infinity, with float f(x) operands +Infinity / Infinity = NaN, with float f(x) operands +Infinity + Infinity = Infinity, with float lExpr operands +Infinity - Infinity = NaN, with float lExpr operands +Infinity * Infinity = Infinity, with float lExpr operands +Infinity / Infinity = NaN, with float lExpr operands +Infinity + Infinity = Infinity, with float rExpr operands +Infinity - Infinity = NaN, with float rExpr operands +Infinity * Infinity = Infinity, with float rExpr operands +Infinity / Infinity = NaN, with float rExpr operands +Infinity + Infinity = Infinity, with float exprs operands +Infinity - Infinity = NaN, with float exprs operands +Infinity * Infinity = Infinity, with float exprs operands +Infinity / Infinity = NaN, with float exprs operands +Infinity + NaN = NaN, with float param operands +Infinity - NaN = NaN, with float param operands +Infinity * NaN = NaN, with float param operands +Infinity / NaN = NaN, with float param operands +Infinity + NaN = NaN, with float local operands +Infinity - NaN = NaN, with float local operands +Infinity * NaN = NaN, with float local operands +Infinity / NaN = NaN, with float local operands +Infinity + NaN = NaN, with float static operands +Infinity - NaN = NaN, with float static operands +Infinity * NaN = NaN, with float static operands +Infinity / NaN = NaN, with float static operands +Infinity + NaN = NaN, with float field operands +Infinity - NaN = NaN, with float field operands +Infinity * NaN = NaN, with float field operands +Infinity / NaN = NaN, with float field operands +Infinity + NaN = NaN, with float a[i] operands +Infinity - NaN = NaN, with float a[i] operands +Infinity * NaN = NaN, with float a[i] operands +Infinity / NaN = NaN, with float a[i] operands +Infinity + NaN = NaN, with float f(x) operands +Infinity - NaN = NaN, with float f(x) operands +Infinity * NaN = NaN, with float f(x) operands +Infinity / NaN = NaN, with float f(x) operands +Infinity + NaN = NaN, with float lExpr operands +Infinity - NaN = NaN, with float lExpr operands +Infinity * NaN = NaN, with float lExpr operands +Infinity / NaN = NaN, with float lExpr operands +Infinity + NaN = NaN, with float rExpr operands +Infinity - NaN = NaN, with float rExpr operands +Infinity * NaN = NaN, with float rExpr operands +Infinity / NaN = NaN, with float rExpr operands +Infinity + NaN = NaN, with float exprs operands +Infinity - NaN = NaN, with float exprs operands +Infinity * NaN = NaN, with float exprs operands +Infinity / NaN = NaN, with float exprs operands +NaN + 1.4E-45 = NaN, with float param operands +NaN - 1.4E-45 = NaN, with float param operands +NaN * 1.4E-45 = NaN, with float param operands +NaN / 1.4E-45 = NaN, with float param operands +NaN + 1.4E-45 = NaN, with float local operands +NaN - 1.4E-45 = NaN, with float local operands +NaN * 1.4E-45 = NaN, with float local operands +NaN / 1.4E-45 = NaN, with float local operands +NaN + 1.4E-45 = NaN, with float static operands +NaN - 1.4E-45 = NaN, with float static operands +NaN * 1.4E-45 = NaN, with float static operands +NaN / 1.4E-45 = NaN, with float static operands +NaN + 1.4E-45 = NaN, with float field operands +NaN - 1.4E-45 = NaN, with float field operands +NaN * 1.4E-45 = NaN, with float field operands +NaN / 1.4E-45 = NaN, with float field operands +NaN + 1.4E-45 = NaN, with float a[i] operands +NaN - 1.4E-45 = NaN, with float a[i] operands +NaN * 1.4E-45 = NaN, with float a[i] operands +NaN / 1.4E-45 = NaN, with float a[i] operands +NaN + 1.4E-45 = NaN, with float f(x) operands +NaN - 1.4E-45 = NaN, with float f(x) operands +NaN * 1.4E-45 = NaN, with float f(x) operands +NaN / 1.4E-45 = NaN, with float f(x) operands +NaN + 1.4E-45 = NaN, with float lExpr operands +NaN - 1.4E-45 = NaN, with float lExpr operands +NaN * 1.4E-45 = NaN, with float lExpr operands +NaN / 1.4E-45 = NaN, with float lExpr operands +NaN + 1.4E-45 = NaN, with float rExpr operands +NaN - 1.4E-45 = NaN, with float rExpr operands +NaN * 1.4E-45 = NaN, with float rExpr operands +NaN / 1.4E-45 = NaN, with float rExpr operands +NaN + 1.4E-45 = NaN, with float exprs operands +NaN - 1.4E-45 = NaN, with float exprs operands +NaN * 1.4E-45 = NaN, with float exprs operands +NaN / 1.4E-45 = NaN, with float exprs operands +NaN + 3.4028235E38 = NaN, with float param operands +NaN - 3.4028235E38 = NaN, with float param operands +NaN * 3.4028235E38 = NaN, with float param operands +NaN / 3.4028235E38 = NaN, with float param operands +NaN + 3.4028235E38 = NaN, with float local operands +NaN - 3.4028235E38 = NaN, with float local operands +NaN * 3.4028235E38 = NaN, with float local operands +NaN / 3.4028235E38 = NaN, with float local operands +NaN + 3.4028235E38 = NaN, with float static operands +NaN - 3.4028235E38 = NaN, with float static operands +NaN * 3.4028235E38 = NaN, with float static operands +NaN / 3.4028235E38 = NaN, with float static operands +NaN + 3.4028235E38 = NaN, with float field operands +NaN - 3.4028235E38 = NaN, with float field operands +NaN * 3.4028235E38 = NaN, with float field operands +NaN / 3.4028235E38 = NaN, with float field operands +NaN + 3.4028235E38 = NaN, with float a[i] operands +NaN - 3.4028235E38 = NaN, with float a[i] operands +NaN * 3.4028235E38 = NaN, with float a[i] operands +NaN / 3.4028235E38 = NaN, with float a[i] operands +NaN + 3.4028235E38 = NaN, with float f(x) operands +NaN - 3.4028235E38 = NaN, with float f(x) operands +NaN * 3.4028235E38 = NaN, with float f(x) operands +NaN / 3.4028235E38 = NaN, with float f(x) operands +NaN + 3.4028235E38 = NaN, with float lExpr operands +NaN - 3.4028235E38 = NaN, with float lExpr operands +NaN * 3.4028235E38 = NaN, with float lExpr operands +NaN / 3.4028235E38 = NaN, with float lExpr operands +NaN + 3.4028235E38 = NaN, with float rExpr operands +NaN - 3.4028235E38 = NaN, with float rExpr operands +NaN * 3.4028235E38 = NaN, with float rExpr operands +NaN / 3.4028235E38 = NaN, with float rExpr operands +NaN + 3.4028235E38 = NaN, with float exprs operands +NaN - 3.4028235E38 = NaN, with float exprs operands +NaN * 3.4028235E38 = NaN, with float exprs operands +NaN / 3.4028235E38 = NaN, with float exprs operands +NaN + -1.4E-45 = NaN, with float param operands +NaN - -1.4E-45 = NaN, with float param operands +NaN * -1.4E-45 = NaN, with float param operands +NaN / -1.4E-45 = NaN, with float param operands +NaN + -1.4E-45 = NaN, with float local operands +NaN - -1.4E-45 = NaN, with float local operands +NaN * -1.4E-45 = NaN, with float local operands +NaN / -1.4E-45 = NaN, with float local operands +NaN + -1.4E-45 = NaN, with float static operands +NaN - -1.4E-45 = NaN, with float static operands +NaN * -1.4E-45 = NaN, with float static operands +NaN / -1.4E-45 = NaN, with float static operands +NaN + -1.4E-45 = NaN, with float field operands +NaN - -1.4E-45 = NaN, with float field operands +NaN * -1.4E-45 = NaN, with float field operands +NaN / -1.4E-45 = NaN, with float field operands +NaN + -1.4E-45 = NaN, with float a[i] operands +NaN - -1.4E-45 = NaN, with float a[i] operands +NaN * -1.4E-45 = NaN, with float a[i] operands +NaN / -1.4E-45 = NaN, with float a[i] operands +NaN + -1.4E-45 = NaN, with float f(x) operands +NaN - -1.4E-45 = NaN, with float f(x) operands +NaN * -1.4E-45 = NaN, with float f(x) operands +NaN / -1.4E-45 = NaN, with float f(x) operands +NaN + -1.4E-45 = NaN, with float lExpr operands +NaN - -1.4E-45 = NaN, with float lExpr operands +NaN * -1.4E-45 = NaN, with float lExpr operands +NaN / -1.4E-45 = NaN, with float lExpr operands +NaN + -1.4E-45 = NaN, with float rExpr operands +NaN - -1.4E-45 = NaN, with float rExpr operands +NaN * -1.4E-45 = NaN, with float rExpr operands +NaN / -1.4E-45 = NaN, with float rExpr operands +NaN + -1.4E-45 = NaN, with float exprs operands +NaN - -1.4E-45 = NaN, with float exprs operands +NaN * -1.4E-45 = NaN, with float exprs operands +NaN / -1.4E-45 = NaN, with float exprs operands +NaN + -3.4028235E38 = NaN, with float param operands +NaN - -3.4028235E38 = NaN, with float param operands +NaN * -3.4028235E38 = NaN, with float param operands +NaN / -3.4028235E38 = NaN, with float param operands +NaN + -3.4028235E38 = NaN, with float local operands +NaN - -3.4028235E38 = NaN, with float local operands +NaN * -3.4028235E38 = NaN, with float local operands +NaN / -3.4028235E38 = NaN, with float local operands +NaN + -3.4028235E38 = NaN, with float static operands +NaN - -3.4028235E38 = NaN, with float static operands +NaN * -3.4028235E38 = NaN, with float static operands +NaN / -3.4028235E38 = NaN, with float static operands +NaN + -3.4028235E38 = NaN, with float field operands +NaN - -3.4028235E38 = NaN, with float field operands +NaN * -3.4028235E38 = NaN, with float field operands +NaN / -3.4028235E38 = NaN, with float field operands +NaN + -3.4028235E38 = NaN, with float a[i] operands +NaN - -3.4028235E38 = NaN, with float a[i] operands +NaN * -3.4028235E38 = NaN, with float a[i] operands +NaN / -3.4028235E38 = NaN, with float a[i] operands +NaN + -3.4028235E38 = NaN, with float f(x) operands +NaN - -3.4028235E38 = NaN, with float f(x) operands +NaN * -3.4028235E38 = NaN, with float f(x) operands +NaN / -3.4028235E38 = NaN, with float f(x) operands +NaN + -3.4028235E38 = NaN, with float lExpr operands +NaN - -3.4028235E38 = NaN, with float lExpr operands +NaN * -3.4028235E38 = NaN, with float lExpr operands +NaN / -3.4028235E38 = NaN, with float lExpr operands +NaN + -3.4028235E38 = NaN, with float rExpr operands +NaN - -3.4028235E38 = NaN, with float rExpr operands +NaN * -3.4028235E38 = NaN, with float rExpr operands +NaN / -3.4028235E38 = NaN, with float rExpr operands +NaN + -3.4028235E38 = NaN, with float exprs operands +NaN - -3.4028235E38 = NaN, with float exprs operands +NaN * -3.4028235E38 = NaN, with float exprs operands +NaN / -3.4028235E38 = NaN, with float exprs operands +NaN + -1.0 = NaN, with float param operands +NaN - -1.0 = NaN, with float param operands +NaN * -1.0 = NaN, with float param operands +NaN / -1.0 = NaN, with float param operands +NaN + -1.0 = NaN, with float local operands +NaN - -1.0 = NaN, with float local operands +NaN * -1.0 = NaN, with float local operands +NaN / -1.0 = NaN, with float local operands +NaN + -1.0 = NaN, with float static operands +NaN - -1.0 = NaN, with float static operands +NaN * -1.0 = NaN, with float static operands +NaN / -1.0 = NaN, with float static operands +NaN + -1.0 = NaN, with float field operands +NaN - -1.0 = NaN, with float field operands +NaN * -1.0 = NaN, with float field operands +NaN / -1.0 = NaN, with float field operands +NaN + -1.0 = NaN, with float a[i] operands +NaN - -1.0 = NaN, with float a[i] operands +NaN * -1.0 = NaN, with float a[i] operands +NaN / -1.0 = NaN, with float a[i] operands +NaN + -1.0 = NaN, with float f(x) operands +NaN - -1.0 = NaN, with float f(x) operands +NaN * -1.0 = NaN, with float f(x) operands +NaN / -1.0 = NaN, with float f(x) operands +NaN + -1.0 = NaN, with float lExpr operands +NaN - -1.0 = NaN, with float lExpr operands +NaN * -1.0 = NaN, with float lExpr operands +NaN / -1.0 = NaN, with float lExpr operands +NaN + -1.0 = NaN, with float rExpr operands +NaN - -1.0 = NaN, with float rExpr operands +NaN * -1.0 = NaN, with float rExpr operands +NaN / -1.0 = NaN, with float rExpr operands +NaN + -1.0 = NaN, with float exprs operands +NaN - -1.0 = NaN, with float exprs operands +NaN * -1.0 = NaN, with float exprs operands +NaN / -1.0 = NaN, with float exprs operands +NaN + 1.0 = NaN, with float param operands +NaN - 1.0 = NaN, with float param operands +NaN * 1.0 = NaN, with float param operands +NaN / 1.0 = NaN, with float param operands +NaN + 1.0 = NaN, with float local operands +NaN - 1.0 = NaN, with float local operands +NaN * 1.0 = NaN, with float local operands +NaN / 1.0 = NaN, with float local operands +NaN + 1.0 = NaN, with float static operands +NaN - 1.0 = NaN, with float static operands +NaN * 1.0 = NaN, with float static operands +NaN / 1.0 = NaN, with float static operands +NaN + 1.0 = NaN, with float field operands +NaN - 1.0 = NaN, with float field operands +NaN * 1.0 = NaN, with float field operands +NaN / 1.0 = NaN, with float field operands +NaN + 1.0 = NaN, with float a[i] operands +NaN - 1.0 = NaN, with float a[i] operands +NaN * 1.0 = NaN, with float a[i] operands +NaN / 1.0 = NaN, with float a[i] operands +NaN + 1.0 = NaN, with float f(x) operands +NaN - 1.0 = NaN, with float f(x) operands +NaN * 1.0 = NaN, with float f(x) operands +NaN / 1.0 = NaN, with float f(x) operands +NaN + 1.0 = NaN, with float lExpr operands +NaN - 1.0 = NaN, with float lExpr operands +NaN * 1.0 = NaN, with float lExpr operands +NaN / 1.0 = NaN, with float lExpr operands +NaN + 1.0 = NaN, with float rExpr operands +NaN - 1.0 = NaN, with float rExpr operands +NaN * 1.0 = NaN, with float rExpr operands +NaN / 1.0 = NaN, with float rExpr operands +NaN + 1.0 = NaN, with float exprs operands +NaN - 1.0 = NaN, with float exprs operands +NaN * 1.0 = NaN, with float exprs operands +NaN / 1.0 = NaN, with float exprs operands +NaN + -0.0 = NaN, with float param operands +NaN - -0.0 = NaN, with float param operands +NaN * -0.0 = NaN, with float param operands +NaN / -0.0 = NaN, with float param operands +NaN + -0.0 = NaN, with float local operands +NaN - -0.0 = NaN, with float local operands +NaN * -0.0 = NaN, with float local operands +NaN / -0.0 = NaN, with float local operands +NaN + -0.0 = NaN, with float static operands +NaN - -0.0 = NaN, with float static operands +NaN * -0.0 = NaN, with float static operands +NaN / -0.0 = NaN, with float static operands +NaN + -0.0 = NaN, with float field operands +NaN - -0.0 = NaN, with float field operands +NaN * -0.0 = NaN, with float field operands +NaN / -0.0 = NaN, with float field operands +NaN + -0.0 = NaN, with float a[i] operands +NaN - -0.0 = NaN, with float a[i] operands +NaN * -0.0 = NaN, with float a[i] operands +NaN / -0.0 = NaN, with float a[i] operands +NaN + -0.0 = NaN, with float f(x) operands +NaN - -0.0 = NaN, with float f(x) operands +NaN * -0.0 = NaN, with float f(x) operands +NaN / -0.0 = NaN, with float f(x) operands +NaN + -0.0 = NaN, with float lExpr operands +NaN - -0.0 = NaN, with float lExpr operands +NaN * -0.0 = NaN, with float lExpr operands +NaN / -0.0 = NaN, with float lExpr operands +NaN + 0.0 = NaN, with float rExpr operands +NaN - 0.0 = NaN, with float rExpr operands +NaN * 0.0 = NaN, with float rExpr operands +NaN / 0.0 = NaN, with float rExpr operands +NaN + 0.0 = NaN, with float exprs operands +NaN - 0.0 = NaN, with float exprs operands +NaN * 0.0 = NaN, with float exprs operands +NaN / 0.0 = NaN, with float exprs operands +NaN + 0.0 = NaN, with float param operands +NaN - 0.0 = NaN, with float param operands +NaN * 0.0 = NaN, with float param operands +NaN / 0.0 = NaN, with float param operands +NaN + 0.0 = NaN, with float local operands +NaN - 0.0 = NaN, with float local operands +NaN * 0.0 = NaN, with float local operands +NaN / 0.0 = NaN, with float local operands +NaN + 0.0 = NaN, with float static operands +NaN - 0.0 = NaN, with float static operands +NaN * 0.0 = NaN, with float static operands +NaN / 0.0 = NaN, with float static operands +NaN + 0.0 = NaN, with float field operands +NaN - 0.0 = NaN, with float field operands +NaN * 0.0 = NaN, with float field operands +NaN / 0.0 = NaN, with float field operands +NaN + 0.0 = NaN, with float a[i] operands +NaN - 0.0 = NaN, with float a[i] operands +NaN * 0.0 = NaN, with float a[i] operands +NaN / 0.0 = NaN, with float a[i] operands +NaN + 0.0 = NaN, with float f(x) operands +NaN - 0.0 = NaN, with float f(x) operands +NaN * 0.0 = NaN, with float f(x) operands +NaN / 0.0 = NaN, with float f(x) operands +NaN + 0.0 = NaN, with float lExpr operands +NaN - 0.0 = NaN, with float lExpr operands +NaN * 0.0 = NaN, with float lExpr operands +NaN / 0.0 = NaN, with float lExpr operands +NaN + 0.0 = NaN, with float rExpr operands +NaN - 0.0 = NaN, with float rExpr operands +NaN * 0.0 = NaN, with float rExpr operands +NaN / 0.0 = NaN, with float rExpr operands +NaN + 0.0 = NaN, with float exprs operands +NaN - 0.0 = NaN, with float exprs operands +NaN * 0.0 = NaN, with float exprs operands +NaN / 0.0 = NaN, with float exprs operands +NaN + -Infinity = NaN, with float param operands +NaN - -Infinity = NaN, with float param operands +NaN * -Infinity = NaN, with float param operands +NaN / -Infinity = NaN, with float param operands +NaN + -Infinity = NaN, with float local operands +NaN - -Infinity = NaN, with float local operands +NaN * -Infinity = NaN, with float local operands +NaN / -Infinity = NaN, with float local operands +NaN + -Infinity = NaN, with float static operands +NaN - -Infinity = NaN, with float static operands +NaN * -Infinity = NaN, with float static operands +NaN / -Infinity = NaN, with float static operands +NaN + -Infinity = NaN, with float field operands +NaN - -Infinity = NaN, with float field operands +NaN * -Infinity = NaN, with float field operands +NaN / -Infinity = NaN, with float field operands +NaN + -Infinity = NaN, with float a[i] operands +NaN - -Infinity = NaN, with float a[i] operands +NaN * -Infinity = NaN, with float a[i] operands +NaN / -Infinity = NaN, with float a[i] operands +NaN + -Infinity = NaN, with float f(x) operands +NaN - -Infinity = NaN, with float f(x) operands +NaN * -Infinity = NaN, with float f(x) operands +NaN / -Infinity = NaN, with float f(x) operands +NaN + -Infinity = NaN, with float lExpr operands +NaN - -Infinity = NaN, with float lExpr operands +NaN * -Infinity = NaN, with float lExpr operands +NaN / -Infinity = NaN, with float lExpr operands +NaN + -Infinity = NaN, with float rExpr operands +NaN - -Infinity = NaN, with float rExpr operands +NaN * -Infinity = NaN, with float rExpr operands +NaN / -Infinity = NaN, with float rExpr operands +NaN + -Infinity = NaN, with float exprs operands +NaN - -Infinity = NaN, with float exprs operands +NaN * -Infinity = NaN, with float exprs operands +NaN / -Infinity = NaN, with float exprs operands +NaN + Infinity = NaN, with float param operands +NaN - Infinity = NaN, with float param operands +NaN * Infinity = NaN, with float param operands +NaN / Infinity = NaN, with float param operands +NaN + Infinity = NaN, with float local operands +NaN - Infinity = NaN, with float local operands +NaN * Infinity = NaN, with float local operands +NaN / Infinity = NaN, with float local operands +NaN + Infinity = NaN, with float static operands +NaN - Infinity = NaN, with float static operands +NaN * Infinity = NaN, with float static operands +NaN / Infinity = NaN, with float static operands +NaN + Infinity = NaN, with float field operands +NaN - Infinity = NaN, with float field operands +NaN * Infinity = NaN, with float field operands +NaN / Infinity = NaN, with float field operands +NaN + Infinity = NaN, with float a[i] operands +NaN - Infinity = NaN, with float a[i] operands +NaN * Infinity = NaN, with float a[i] operands +NaN / Infinity = NaN, with float a[i] operands +NaN + Infinity = NaN, with float f(x) operands +NaN - Infinity = NaN, with float f(x) operands +NaN * Infinity = NaN, with float f(x) operands +NaN / Infinity = NaN, with float f(x) operands +NaN + Infinity = NaN, with float lExpr operands +NaN - Infinity = NaN, with float lExpr operands +NaN * Infinity = NaN, with float lExpr operands +NaN / Infinity = NaN, with float lExpr operands +NaN + Infinity = NaN, with float rExpr operands +NaN - Infinity = NaN, with float rExpr operands +NaN * Infinity = NaN, with float rExpr operands +NaN / Infinity = NaN, with float rExpr operands +NaN + Infinity = NaN, with float exprs operands +NaN - Infinity = NaN, with float exprs operands +NaN * Infinity = NaN, with float exprs operands +NaN / Infinity = NaN, with float exprs operands +NaN + NaN = NaN, with float param operands +NaN - NaN = NaN, with float param operands +NaN * NaN = NaN, with float param operands +NaN / NaN = NaN, with float param operands +NaN + NaN = NaN, with float local operands +NaN - NaN = NaN, with float local operands +NaN * NaN = NaN, with float local operands +NaN / NaN = NaN, with float local operands +NaN + NaN = NaN, with float static operands +NaN - NaN = NaN, with float static operands +NaN * NaN = NaN, with float static operands +NaN / NaN = NaN, with float static operands +NaN + NaN = NaN, with float field operands +NaN - NaN = NaN, with float field operands +NaN * NaN = NaN, with float field operands +NaN / NaN = NaN, with float field operands +NaN + NaN = NaN, with float a[i] operands +NaN - NaN = NaN, with float a[i] operands +NaN * NaN = NaN, with float a[i] operands +NaN / NaN = NaN, with float a[i] operands +NaN + NaN = NaN, with float f(x) operands +NaN - NaN = NaN, with float f(x) operands +NaN * NaN = NaN, with float f(x) operands +NaN / NaN = NaN, with float f(x) operands +NaN + NaN = NaN, with float lExpr operands +NaN - NaN = NaN, with float lExpr operands +NaN * NaN = NaN, with float lExpr operands +NaN / NaN = NaN, with float lExpr operands +NaN + NaN = NaN, with float rExpr operands +NaN - NaN = NaN, with float rExpr operands +NaN * NaN = NaN, with float rExpr operands +NaN / NaN = NaN, with float rExpr operands +NaN + NaN = NaN, with float exprs operands +NaN - NaN = NaN, with float exprs operands +NaN * NaN = NaN, with float exprs operands +NaN / NaN = NaN, with float exprs operands +4.9E-324 + 4.9E-324 = 1.0E-323, with double param operands +4.9E-324 - 4.9E-324 = 0.0, with double param operands +4.9E-324 * 4.9E-324 = 0.0, with double param operands +4.9E-324 / 4.9E-324 = 1.0, with double param operands +4.9E-324 + 4.9E-324 = 1.0E-323, with double local operands +4.9E-324 - 4.9E-324 = 0.0, with double local operands +4.9E-324 * 4.9E-324 = 0.0, with double local operands +4.9E-324 / 4.9E-324 = 1.0, with double local operands +4.9E-324 + 4.9E-324 = 1.0E-323, with double static operands +4.9E-324 - 4.9E-324 = 0.0, with double static operands +4.9E-324 * 4.9E-324 = 0.0, with double static operands +4.9E-324 / 4.9E-324 = 1.0, with double static operands +4.9E-324 + 4.9E-324 = 1.0E-323, with double field operands +4.9E-324 - 4.9E-324 = 0.0, with double field operands +4.9E-324 * 4.9E-324 = 0.0, with double field operands +4.9E-324 / 4.9E-324 = 1.0, with double field operands +4.9E-324 + 4.9E-324 = 1.0E-323, with double a[i] operands +4.9E-324 - 4.9E-324 = 0.0, with double a[i] operands +4.9E-324 * 4.9E-324 = 0.0, with double a[i] operands +4.9E-324 / 4.9E-324 = 1.0, with double a[i] operands +4.9E-324 + 4.9E-324 = 1.0E-323, with double f(x) operands +4.9E-324 - 4.9E-324 = 0.0, with double f(x) operands +4.9E-324 * 4.9E-324 = 0.0, with double f(x) operands +4.9E-324 / 4.9E-324 = 1.0, with double f(x) operands +4.9E-324 + 4.9E-324 = 1.0E-323, with double lExpr operands +4.9E-324 - 4.9E-324 = 0.0, with double lExpr operands +4.9E-324 * 4.9E-324 = 0.0, with double lExpr operands +4.9E-324 / 4.9E-324 = 1.0, with double lExpr operands +4.9E-324 + 4.9E-324 = 1.0E-323, with double rExpr operands +4.9E-324 - 4.9E-324 = 0.0, with double rExpr operands +4.9E-324 * 4.9E-324 = 0.0, with double rExpr operands +4.9E-324 / 4.9E-324 = 1.0, with double rExpr operands +4.9E-324 + 4.9E-324 = 1.0E-323, with double exprs operands +4.9E-324 - 4.9E-324 = 0.0, with double exprs operands +4.9E-324 * 4.9E-324 = 0.0, with double exprs operands +4.9E-324 / 4.9E-324 = 1.0, with double exprs operands +4.9E-324 + 1.7976931348623157E308 = 1.7976931348623157E308, with double param operands +4.9E-324 - 1.7976931348623157E308 = -1.7976931348623157E308, with double param operands +4.9E-324 * 1.7976931348623157E308 = 8.881784197001251E-16, with double param operands +4.9E-324 / 1.7976931348623157E308 = 0.0, with double param operands +4.9E-324 + 1.7976931348623157E308 = 1.7976931348623157E308, with double local operands +4.9E-324 - 1.7976931348623157E308 = -1.7976931348623157E308, with double local operands +4.9E-324 * 1.7976931348623157E308 = 8.881784197001251E-16, with double local operands +4.9E-324 / 1.7976931348623157E308 = 0.0, with double local operands +4.9E-324 + 1.7976931348623157E308 = 1.7976931348623157E308, with double static operands +4.9E-324 - 1.7976931348623157E308 = -1.7976931348623157E308, with double static operands +4.9E-324 * 1.7976931348623157E308 = 8.881784197001251E-16, with double static operands +4.9E-324 / 1.7976931348623157E308 = 0.0, with double static operands +4.9E-324 + 1.7976931348623157E308 = 1.7976931348623157E308, with double field operands +4.9E-324 - 1.7976931348623157E308 = -1.7976931348623157E308, with double field operands +4.9E-324 * 1.7976931348623157E308 = 8.881784197001251E-16, with double field operands +4.9E-324 / 1.7976931348623157E308 = 0.0, with double field operands +4.9E-324 + 1.7976931348623157E308 = 1.7976931348623157E308, with double a[i] operands +4.9E-324 - 1.7976931348623157E308 = -1.7976931348623157E308, with double a[i] operands +4.9E-324 * 1.7976931348623157E308 = 8.881784197001251E-16, with double a[i] operands +4.9E-324 / 1.7976931348623157E308 = 0.0, with double a[i] operands +4.9E-324 + 1.7976931348623157E308 = 1.7976931348623157E308, with double f(x) operands +4.9E-324 - 1.7976931348623157E308 = -1.7976931348623157E308, with double f(x) operands +4.9E-324 * 1.7976931348623157E308 = 8.881784197001251E-16, with double f(x) operands +4.9E-324 / 1.7976931348623157E308 = 0.0, with double f(x) operands +4.9E-324 + 1.7976931348623157E308 = 1.7976931348623157E308, with double lExpr operands +4.9E-324 - 1.7976931348623157E308 = -1.7976931348623157E308, with double lExpr operands +4.9E-324 * 1.7976931348623157E308 = 8.881784197001251E-16, with double lExpr operands +4.9E-324 / 1.7976931348623157E308 = 0.0, with double lExpr operands +4.9E-324 + 1.7976931348623157E308 = 1.7976931348623157E308, with double rExpr operands +4.9E-324 - 1.7976931348623157E308 = -1.7976931348623157E308, with double rExpr operands +4.9E-324 * 1.7976931348623157E308 = 8.881784197001251E-16, with double rExpr operands +4.9E-324 / 1.7976931348623157E308 = 0.0, with double rExpr operands +4.9E-324 + 1.7976931348623157E308 = 1.7976931348623157E308, with double exprs operands +4.9E-324 - 1.7976931348623157E308 = -1.7976931348623157E308, with double exprs operands +4.9E-324 * 1.7976931348623157E308 = 8.881784197001251E-16, with double exprs operands +4.9E-324 / 1.7976931348623157E308 = 0.0, with double exprs operands +4.9E-324 + -4.9E-324 = 0.0, with double param operands +4.9E-324 - -4.9E-324 = 1.0E-323, with double param operands +4.9E-324 * -4.9E-324 = -0.0, with double param operands +4.9E-324 / -4.9E-324 = -1.0, with double param operands +4.9E-324 + -4.9E-324 = 0.0, with double local operands +4.9E-324 - -4.9E-324 = 1.0E-323, with double local operands +4.9E-324 * -4.9E-324 = -0.0, with double local operands +4.9E-324 / -4.9E-324 = -1.0, with double local operands +4.9E-324 + -4.9E-324 = 0.0, with double static operands +4.9E-324 - -4.9E-324 = 1.0E-323, with double static operands +4.9E-324 * -4.9E-324 = -0.0, with double static operands +4.9E-324 / -4.9E-324 = -1.0, with double static operands +4.9E-324 + -4.9E-324 = 0.0, with double field operands +4.9E-324 - -4.9E-324 = 1.0E-323, with double field operands +4.9E-324 * -4.9E-324 = -0.0, with double field operands +4.9E-324 / -4.9E-324 = -1.0, with double field operands +4.9E-324 + -4.9E-324 = 0.0, with double a[i] operands +4.9E-324 - -4.9E-324 = 1.0E-323, with double a[i] operands +4.9E-324 * -4.9E-324 = -0.0, with double a[i] operands +4.9E-324 / -4.9E-324 = -1.0, with double a[i] operands +4.9E-324 + -4.9E-324 = 0.0, with double f(x) operands +4.9E-324 - -4.9E-324 = 1.0E-323, with double f(x) operands +4.9E-324 * -4.9E-324 = -0.0, with double f(x) operands +4.9E-324 / -4.9E-324 = -1.0, with double f(x) operands +4.9E-324 + -4.9E-324 = 0.0, with double lExpr operands +4.9E-324 - -4.9E-324 = 1.0E-323, with double lExpr operands +4.9E-324 * -4.9E-324 = -0.0, with double lExpr operands +4.9E-324 / -4.9E-324 = -1.0, with double lExpr operands +4.9E-324 + -4.9E-324 = 0.0, with double rExpr operands +4.9E-324 - -4.9E-324 = 1.0E-323, with double rExpr operands +4.9E-324 * -4.9E-324 = -0.0, with double rExpr operands +4.9E-324 / -4.9E-324 = -1.0, with double rExpr operands +4.9E-324 + -4.9E-324 = 0.0, with double exprs operands +4.9E-324 - -4.9E-324 = 1.0E-323, with double exprs operands +4.9E-324 * -4.9E-324 = -0.0, with double exprs operands +4.9E-324 / -4.9E-324 = -1.0, with double exprs operands +4.9E-324 + -1.7976931348623157E308 = -1.7976931348623157E308, with double param operands +4.9E-324 - -1.7976931348623157E308 = 1.7976931348623157E308, with double param operands +4.9E-324 * -1.7976931348623157E308 = -8.881784197001251E-16, with double param operands +4.9E-324 / -1.7976931348623157E308 = -0.0, with double param operands +4.9E-324 + -1.7976931348623157E308 = -1.7976931348623157E308, with double local operands +4.9E-324 - -1.7976931348623157E308 = 1.7976931348623157E308, with double local operands +4.9E-324 * -1.7976931348623157E308 = -8.881784197001251E-16, with double local operands +4.9E-324 / -1.7976931348623157E308 = -0.0, with double local operands +4.9E-324 + -1.7976931348623157E308 = -1.7976931348623157E308, with double static operands +4.9E-324 - -1.7976931348623157E308 = 1.7976931348623157E308, with double static operands +4.9E-324 * -1.7976931348623157E308 = -8.881784197001251E-16, with double static operands +4.9E-324 / -1.7976931348623157E308 = -0.0, with double static operands +4.9E-324 + -1.7976931348623157E308 = -1.7976931348623157E308, with double field operands +4.9E-324 - -1.7976931348623157E308 = 1.7976931348623157E308, with double field operands +4.9E-324 * -1.7976931348623157E308 = -8.881784197001251E-16, with double field operands +4.9E-324 / -1.7976931348623157E308 = -0.0, with double field operands +4.9E-324 + -1.7976931348623157E308 = -1.7976931348623157E308, with double a[i] operands +4.9E-324 - -1.7976931348623157E308 = 1.7976931348623157E308, with double a[i] operands +4.9E-324 * -1.7976931348623157E308 = -8.881784197001251E-16, with double a[i] operands +4.9E-324 / -1.7976931348623157E308 = -0.0, with double a[i] operands +4.9E-324 + -1.7976931348623157E308 = -1.7976931348623157E308, with double f(x) operands +4.9E-324 - -1.7976931348623157E308 = 1.7976931348623157E308, with double f(x) operands +4.9E-324 * -1.7976931348623157E308 = -8.881784197001251E-16, with double f(x) operands +4.9E-324 / -1.7976931348623157E308 = -0.0, with double f(x) operands +4.9E-324 + -1.7976931348623157E308 = -1.7976931348623157E308, with double lExpr operands +4.9E-324 - -1.7976931348623157E308 = 1.7976931348623157E308, with double lExpr operands +4.9E-324 * -1.7976931348623157E308 = -8.881784197001251E-16, with double lExpr operands +4.9E-324 / -1.7976931348623157E308 = -0.0, with double lExpr operands +4.9E-324 + -1.7976931348623157E308 = -1.7976931348623157E308, with double rExpr operands +4.9E-324 - -1.7976931348623157E308 = 1.7976931348623157E308, with double rExpr operands +4.9E-324 * -1.7976931348623157E308 = -8.881784197001251E-16, with double rExpr operands +4.9E-324 / -1.7976931348623157E308 = -0.0, with double rExpr operands +4.9E-324 + -1.7976931348623157E308 = -1.7976931348623157E308, with double exprs operands +4.9E-324 - -1.7976931348623157E308 = 1.7976931348623157E308, with double exprs operands +4.9E-324 * -1.7976931348623157E308 = -8.881784197001251E-16, with double exprs operands +4.9E-324 / -1.7976931348623157E308 = -0.0, with double exprs operands +4.9E-324 + -1.0 = -1.0, with double param operands +4.9E-324 - -1.0 = 1.0, with double param operands +4.9E-324 * -1.0 = -4.9E-324, with double param operands +4.9E-324 / -1.0 = -4.9E-324, with double param operands +4.9E-324 + -1.0 = -1.0, with double local operands +4.9E-324 - -1.0 = 1.0, with double local operands +4.9E-324 * -1.0 = -4.9E-324, with double local operands +4.9E-324 / -1.0 = -4.9E-324, with double local operands +4.9E-324 + -1.0 = -1.0, with double static operands +4.9E-324 - -1.0 = 1.0, with double static operands +4.9E-324 * -1.0 = -4.9E-324, with double static operands +4.9E-324 / -1.0 = -4.9E-324, with double static operands +4.9E-324 + -1.0 = -1.0, with double field operands +4.9E-324 - -1.0 = 1.0, with double field operands +4.9E-324 * -1.0 = -4.9E-324, with double field operands +4.9E-324 / -1.0 = -4.9E-324, with double field operands +4.9E-324 + -1.0 = -1.0, with double a[i] operands +4.9E-324 - -1.0 = 1.0, with double a[i] operands +4.9E-324 * -1.0 = -4.9E-324, with double a[i] operands +4.9E-324 / -1.0 = -4.9E-324, with double a[i] operands +4.9E-324 + -1.0 = -1.0, with double f(x) operands +4.9E-324 - -1.0 = 1.0, with double f(x) operands +4.9E-324 * -1.0 = -4.9E-324, with double f(x) operands +4.9E-324 / -1.0 = -4.9E-324, with double f(x) operands +4.9E-324 + -1.0 = -1.0, with double lExpr operands +4.9E-324 - -1.0 = 1.0, with double lExpr operands +4.9E-324 * -1.0 = -4.9E-324, with double lExpr operands +4.9E-324 / -1.0 = -4.9E-324, with double lExpr operands +4.9E-324 + -1.0 = -1.0, with double rExpr operands +4.9E-324 - -1.0 = 1.0, with double rExpr operands +4.9E-324 * -1.0 = -4.9E-324, with double rExpr operands +4.9E-324 / -1.0 = -4.9E-324, with double rExpr operands +4.9E-324 + -1.0 = -1.0, with double exprs operands +4.9E-324 - -1.0 = 1.0, with double exprs operands +4.9E-324 * -1.0 = -4.9E-324, with double exprs operands +4.9E-324 / -1.0 = -4.9E-324, with double exprs operands +4.9E-324 + 1.0 = 1.0, with double param operands +4.9E-324 - 1.0 = -1.0, with double param operands +4.9E-324 * 1.0 = 4.9E-324, with double param operands +4.9E-324 / 1.0 = 4.9E-324, with double param operands +4.9E-324 + 1.0 = 1.0, with double local operands +4.9E-324 - 1.0 = -1.0, with double local operands +4.9E-324 * 1.0 = 4.9E-324, with double local operands +4.9E-324 / 1.0 = 4.9E-324, with double local operands +4.9E-324 + 1.0 = 1.0, with double static operands +4.9E-324 - 1.0 = -1.0, with double static operands +4.9E-324 * 1.0 = 4.9E-324, with double static operands +4.9E-324 / 1.0 = 4.9E-324, with double static operands +4.9E-324 + 1.0 = 1.0, with double field operands +4.9E-324 - 1.0 = -1.0, with double field operands +4.9E-324 * 1.0 = 4.9E-324, with double field operands +4.9E-324 / 1.0 = 4.9E-324, with double field operands +4.9E-324 + 1.0 = 1.0, with double a[i] operands +4.9E-324 - 1.0 = -1.0, with double a[i] operands +4.9E-324 * 1.0 = 4.9E-324, with double a[i] operands +4.9E-324 / 1.0 = 4.9E-324, with double a[i] operands +4.9E-324 + 1.0 = 1.0, with double f(x) operands +4.9E-324 - 1.0 = -1.0, with double f(x) operands +4.9E-324 * 1.0 = 4.9E-324, with double f(x) operands +4.9E-324 / 1.0 = 4.9E-324, with double f(x) operands +4.9E-324 + 1.0 = 1.0, with double lExpr operands +4.9E-324 - 1.0 = -1.0, with double lExpr operands +4.9E-324 * 1.0 = 4.9E-324, with double lExpr operands +4.9E-324 / 1.0 = 4.9E-324, with double lExpr operands +4.9E-324 + 1.0 = 1.0, with double rExpr operands +4.9E-324 - 1.0 = -1.0, with double rExpr operands +4.9E-324 * 1.0 = 4.9E-324, with double rExpr operands +4.9E-324 / 1.0 = 4.9E-324, with double rExpr operands +4.9E-324 + 1.0 = 1.0, with double exprs operands +4.9E-324 - 1.0 = -1.0, with double exprs operands +4.9E-324 * 1.0 = 4.9E-324, with double exprs operands +4.9E-324 / 1.0 = 4.9E-324, with double exprs operands +4.9E-324 + -0.0 = 4.9E-324, with double param operands +4.9E-324 - -0.0 = 4.9E-324, with double param operands +4.9E-324 * -0.0 = -0.0, with double param operands +4.9E-324 / -0.0 = -Infinity, with double param operands +4.9E-324 + -0.0 = 4.9E-324, with double local operands +4.9E-324 - -0.0 = 4.9E-324, with double local operands +4.9E-324 * -0.0 = -0.0, with double local operands +4.9E-324 / -0.0 = -Infinity, with double local operands +4.9E-324 + -0.0 = 4.9E-324, with double static operands +4.9E-324 - -0.0 = 4.9E-324, with double static operands +4.9E-324 * -0.0 = -0.0, with double static operands +4.9E-324 / -0.0 = -Infinity, with double static operands +4.9E-324 + -0.0 = 4.9E-324, with double field operands +4.9E-324 - -0.0 = 4.9E-324, with double field operands +4.9E-324 * -0.0 = -0.0, with double field operands +4.9E-324 / -0.0 = -Infinity, with double field operands +4.9E-324 + -0.0 = 4.9E-324, with double a[i] operands +4.9E-324 - -0.0 = 4.9E-324, with double a[i] operands +4.9E-324 * -0.0 = -0.0, with double a[i] operands +4.9E-324 / -0.0 = -Infinity, with double a[i] operands +4.9E-324 + -0.0 = 4.9E-324, with double f(x) operands +4.9E-324 - -0.0 = 4.9E-324, with double f(x) operands +4.9E-324 * -0.0 = -0.0, with double f(x) operands +4.9E-324 / -0.0 = -Infinity, with double f(x) operands +4.9E-324 + -0.0 = 4.9E-324, with double lExpr operands +4.9E-324 - -0.0 = 4.9E-324, with double lExpr operands +4.9E-324 * -0.0 = -0.0, with double lExpr operands +4.9E-324 / -0.0 = -Infinity, with double lExpr operands +4.9E-324 + 0.0 = 4.9E-324, with double rExpr operands +4.9E-324 - 0.0 = 4.9E-324, with double rExpr operands +4.9E-324 * 0.0 = 0.0, with double rExpr operands +4.9E-324 / 0.0 = Infinity, with double rExpr operands +4.9E-324 + 0.0 = 4.9E-324, with double exprs operands +4.9E-324 - 0.0 = 4.9E-324, with double exprs operands +4.9E-324 * 0.0 = 0.0, with double exprs operands +4.9E-324 / 0.0 = Infinity, with double exprs operands +4.9E-324 + 0.0 = 4.9E-324, with double param operands +4.9E-324 - 0.0 = 4.9E-324, with double param operands +4.9E-324 * 0.0 = 0.0, with double param operands +4.9E-324 / 0.0 = Infinity, with double param operands +4.9E-324 + 0.0 = 4.9E-324, with double local operands +4.9E-324 - 0.0 = 4.9E-324, with double local operands +4.9E-324 * 0.0 = 0.0, with double local operands +4.9E-324 / 0.0 = Infinity, with double local operands +4.9E-324 + 0.0 = 4.9E-324, with double static operands +4.9E-324 - 0.0 = 4.9E-324, with double static operands +4.9E-324 * 0.0 = 0.0, with double static operands +4.9E-324 / 0.0 = Infinity, with double static operands +4.9E-324 + 0.0 = 4.9E-324, with double field operands +4.9E-324 - 0.0 = 4.9E-324, with double field operands +4.9E-324 * 0.0 = 0.0, with double field operands +4.9E-324 / 0.0 = Infinity, with double field operands +4.9E-324 + 0.0 = 4.9E-324, with double a[i] operands +4.9E-324 - 0.0 = 4.9E-324, with double a[i] operands +4.9E-324 * 0.0 = 0.0, with double a[i] operands +4.9E-324 / 0.0 = Infinity, with double a[i] operands +4.9E-324 + 0.0 = 4.9E-324, with double f(x) operands +4.9E-324 - 0.0 = 4.9E-324, with double f(x) operands +4.9E-324 * 0.0 = 0.0, with double f(x) operands +4.9E-324 / 0.0 = Infinity, with double f(x) operands +4.9E-324 + 0.0 = 4.9E-324, with double lExpr operands +4.9E-324 - 0.0 = 4.9E-324, with double lExpr operands +4.9E-324 * 0.0 = 0.0, with double lExpr operands +4.9E-324 / 0.0 = Infinity, with double lExpr operands +4.9E-324 + 0.0 = 4.9E-324, with double rExpr operands +4.9E-324 - 0.0 = 4.9E-324, with double rExpr operands +4.9E-324 * 0.0 = 0.0, with double rExpr operands +4.9E-324 / 0.0 = Infinity, with double rExpr operands +4.9E-324 + 0.0 = 4.9E-324, with double exprs operands +4.9E-324 - 0.0 = 4.9E-324, with double exprs operands +4.9E-324 * 0.0 = 0.0, with double exprs operands +4.9E-324 / 0.0 = Infinity, with double exprs operands +4.9E-324 + -Infinity = -Infinity, with double param operands +4.9E-324 - -Infinity = Infinity, with double param operands +4.9E-324 * -Infinity = -Infinity, with double param operands +4.9E-324 / -Infinity = -0.0, with double param operands +4.9E-324 + -Infinity = -Infinity, with double local operands +4.9E-324 - -Infinity = Infinity, with double local operands +4.9E-324 * -Infinity = -Infinity, with double local operands +4.9E-324 / -Infinity = -0.0, with double local operands +4.9E-324 + -Infinity = -Infinity, with double static operands +4.9E-324 - -Infinity = Infinity, with double static operands +4.9E-324 * -Infinity = -Infinity, with double static operands +4.9E-324 / -Infinity = -0.0, with double static operands +4.9E-324 + -Infinity = -Infinity, with double field operands +4.9E-324 - -Infinity = Infinity, with double field operands +4.9E-324 * -Infinity = -Infinity, with double field operands +4.9E-324 / -Infinity = -0.0, with double field operands +4.9E-324 + -Infinity = -Infinity, with double a[i] operands +4.9E-324 - -Infinity = Infinity, with double a[i] operands +4.9E-324 * -Infinity = -Infinity, with double a[i] operands +4.9E-324 / -Infinity = -0.0, with double a[i] operands +4.9E-324 + -Infinity = -Infinity, with double f(x) operands +4.9E-324 - -Infinity = Infinity, with double f(x) operands +4.9E-324 * -Infinity = -Infinity, with double f(x) operands +4.9E-324 / -Infinity = -0.0, with double f(x) operands +4.9E-324 + -Infinity = -Infinity, with double lExpr operands +4.9E-324 - -Infinity = Infinity, with double lExpr operands +4.9E-324 * -Infinity = -Infinity, with double lExpr operands +4.9E-324 / -Infinity = -0.0, with double lExpr operands +4.9E-324 + -Infinity = -Infinity, with double rExpr operands +4.9E-324 - -Infinity = Infinity, with double rExpr operands +4.9E-324 * -Infinity = -Infinity, with double rExpr operands +4.9E-324 / -Infinity = -0.0, with double rExpr operands +4.9E-324 + -Infinity = -Infinity, with double exprs operands +4.9E-324 - -Infinity = Infinity, with double exprs operands +4.9E-324 * -Infinity = -Infinity, with double exprs operands +4.9E-324 / -Infinity = -0.0, with double exprs operands +4.9E-324 + Infinity = Infinity, with double param operands +4.9E-324 - Infinity = -Infinity, with double param operands +4.9E-324 * Infinity = Infinity, with double param operands +4.9E-324 / Infinity = 0.0, with double param operands +4.9E-324 + Infinity = Infinity, with double local operands +4.9E-324 - Infinity = -Infinity, with double local operands +4.9E-324 * Infinity = Infinity, with double local operands +4.9E-324 / Infinity = 0.0, with double local operands +4.9E-324 + Infinity = Infinity, with double static operands +4.9E-324 - Infinity = -Infinity, with double static operands +4.9E-324 * Infinity = Infinity, with double static operands +4.9E-324 / Infinity = 0.0, with double static operands +4.9E-324 + Infinity = Infinity, with double field operands +4.9E-324 - Infinity = -Infinity, with double field operands +4.9E-324 * Infinity = Infinity, with double field operands +4.9E-324 / Infinity = 0.0, with double field operands +4.9E-324 + Infinity = Infinity, with double a[i] operands +4.9E-324 - Infinity = -Infinity, with double a[i] operands +4.9E-324 * Infinity = Infinity, with double a[i] operands +4.9E-324 / Infinity = 0.0, with double a[i] operands +4.9E-324 + Infinity = Infinity, with double f(x) operands +4.9E-324 - Infinity = -Infinity, with double f(x) operands +4.9E-324 * Infinity = Infinity, with double f(x) operands +4.9E-324 / Infinity = 0.0, with double f(x) operands +4.9E-324 + Infinity = Infinity, with double lExpr operands +4.9E-324 - Infinity = -Infinity, with double lExpr operands +4.9E-324 * Infinity = Infinity, with double lExpr operands +4.9E-324 / Infinity = 0.0, with double lExpr operands +4.9E-324 + Infinity = Infinity, with double rExpr operands +4.9E-324 - Infinity = -Infinity, with double rExpr operands +4.9E-324 * Infinity = Infinity, with double rExpr operands +4.9E-324 / Infinity = 0.0, with double rExpr operands +4.9E-324 + Infinity = Infinity, with double exprs operands +4.9E-324 - Infinity = -Infinity, with double exprs operands +4.9E-324 * Infinity = Infinity, with double exprs operands +4.9E-324 / Infinity = 0.0, with double exprs operands +4.9E-324 + NaN = NaN, with double param operands +4.9E-324 - NaN = NaN, with double param operands +4.9E-324 * NaN = NaN, with double param operands +4.9E-324 / NaN = NaN, with double param operands +4.9E-324 + NaN = NaN, with double local operands +4.9E-324 - NaN = NaN, with double local operands +4.9E-324 * NaN = NaN, with double local operands +4.9E-324 / NaN = NaN, with double local operands +4.9E-324 + NaN = NaN, with double static operands +4.9E-324 - NaN = NaN, with double static operands +4.9E-324 * NaN = NaN, with double static operands +4.9E-324 / NaN = NaN, with double static operands +4.9E-324 + NaN = NaN, with double field operands +4.9E-324 - NaN = NaN, with double field operands +4.9E-324 * NaN = NaN, with double field operands +4.9E-324 / NaN = NaN, with double field operands +4.9E-324 + NaN = NaN, with double a[i] operands +4.9E-324 - NaN = NaN, with double a[i] operands +4.9E-324 * NaN = NaN, with double a[i] operands +4.9E-324 / NaN = NaN, with double a[i] operands +4.9E-324 + NaN = NaN, with double f(x) operands +4.9E-324 - NaN = NaN, with double f(x) operands +4.9E-324 * NaN = NaN, with double f(x) operands +4.9E-324 / NaN = NaN, with double f(x) operands +4.9E-324 + NaN = NaN, with double lExpr operands +4.9E-324 - NaN = NaN, with double lExpr operands +4.9E-324 * NaN = NaN, with double lExpr operands +4.9E-324 / NaN = NaN, with double lExpr operands +4.9E-324 + NaN = NaN, with double rExpr operands +4.9E-324 - NaN = NaN, with double rExpr operands +4.9E-324 * NaN = NaN, with double rExpr operands +4.9E-324 / NaN = NaN, with double rExpr operands +4.9E-324 + NaN = NaN, with double exprs operands +4.9E-324 - NaN = NaN, with double exprs operands +4.9E-324 * NaN = NaN, with double exprs operands +4.9E-324 / NaN = NaN, with double exprs operands +1.7976931348623157E308 + 4.9E-324 = 1.7976931348623157E308, with double param operands +1.7976931348623157E308 - 4.9E-324 = 1.7976931348623157E308, with double param operands +1.7976931348623157E308 * 4.9E-324 = 8.881784197001251E-16, with double param operands +1.7976931348623157E308 / 4.9E-324 = Infinity, with double param operands +1.7976931348623157E308 + 4.9E-324 = 1.7976931348623157E308, with double local operands +1.7976931348623157E308 - 4.9E-324 = 1.7976931348623157E308, with double local operands +1.7976931348623157E308 * 4.9E-324 = 8.881784197001251E-16, with double local operands +1.7976931348623157E308 / 4.9E-324 = Infinity, with double local operands +1.7976931348623157E308 + 4.9E-324 = 1.7976931348623157E308, with double static operands +1.7976931348623157E308 - 4.9E-324 = 1.7976931348623157E308, with double static operands +1.7976931348623157E308 * 4.9E-324 = 8.881784197001251E-16, with double static operands +1.7976931348623157E308 / 4.9E-324 = Infinity, with double static operands +1.7976931348623157E308 + 4.9E-324 = 1.7976931348623157E308, with double field operands +1.7976931348623157E308 - 4.9E-324 = 1.7976931348623157E308, with double field operands +1.7976931348623157E308 * 4.9E-324 = 8.881784197001251E-16, with double field operands +1.7976931348623157E308 / 4.9E-324 = Infinity, with double field operands +1.7976931348623157E308 + 4.9E-324 = 1.7976931348623157E308, with double a[i] operands +1.7976931348623157E308 - 4.9E-324 = 1.7976931348623157E308, with double a[i] operands +1.7976931348623157E308 * 4.9E-324 = 8.881784197001251E-16, with double a[i] operands +1.7976931348623157E308 / 4.9E-324 = Infinity, with double a[i] operands +1.7976931348623157E308 + 4.9E-324 = 1.7976931348623157E308, with double f(x) operands +1.7976931348623157E308 - 4.9E-324 = 1.7976931348623157E308, with double f(x) operands +1.7976931348623157E308 * 4.9E-324 = 8.881784197001251E-16, with double f(x) operands +1.7976931348623157E308 / 4.9E-324 = Infinity, with double f(x) operands +1.7976931348623157E308 + 4.9E-324 = 1.7976931348623157E308, with double lExpr operands +1.7976931348623157E308 - 4.9E-324 = 1.7976931348623157E308, with double lExpr operands +1.7976931348623157E308 * 4.9E-324 = 8.881784197001251E-16, with double lExpr operands +1.7976931348623157E308 / 4.9E-324 = Infinity, with double lExpr operands +1.7976931348623157E308 + 4.9E-324 = 1.7976931348623157E308, with double rExpr operands +1.7976931348623157E308 - 4.9E-324 = 1.7976931348623157E308, with double rExpr operands +1.7976931348623157E308 * 4.9E-324 = 8.881784197001251E-16, with double rExpr operands +1.7976931348623157E308 / 4.9E-324 = Infinity, with double rExpr operands +1.7976931348623157E308 + 4.9E-324 = 1.7976931348623157E308, with double exprs operands +1.7976931348623157E308 - 4.9E-324 = 1.7976931348623157E308, with double exprs operands +1.7976931348623157E308 * 4.9E-324 = 8.881784197001251E-16, with double exprs operands +1.7976931348623157E308 / 4.9E-324 = Infinity, with double exprs operands +1.7976931348623157E308 + 1.7976931348623157E308 = Infinity, with double param operands +1.7976931348623157E308 - 1.7976931348623157E308 = 0.0, with double param operands +1.7976931348623157E308 * 1.7976931348623157E308 = Infinity, with double param operands +1.7976931348623157E308 / 1.7976931348623157E308 = 1.0, with double param operands +1.7976931348623157E308 + 1.7976931348623157E308 = Infinity, with double local operands +1.7976931348623157E308 - 1.7976931348623157E308 = 0.0, with double local operands +1.7976931348623157E308 * 1.7976931348623157E308 = Infinity, with double local operands +1.7976931348623157E308 / 1.7976931348623157E308 = 1.0, with double local operands +1.7976931348623157E308 + 1.7976931348623157E308 = Infinity, with double static operands +1.7976931348623157E308 - 1.7976931348623157E308 = 0.0, with double static operands +1.7976931348623157E308 * 1.7976931348623157E308 = Infinity, with double static operands +1.7976931348623157E308 / 1.7976931348623157E308 = 1.0, with double static operands +1.7976931348623157E308 + 1.7976931348623157E308 = Infinity, with double field operands +1.7976931348623157E308 - 1.7976931348623157E308 = 0.0, with double field operands +1.7976931348623157E308 * 1.7976931348623157E308 = Infinity, with double field operands +1.7976931348623157E308 / 1.7976931348623157E308 = 1.0, with double field operands +1.7976931348623157E308 + 1.7976931348623157E308 = Infinity, with double a[i] operands +1.7976931348623157E308 - 1.7976931348623157E308 = 0.0, with double a[i] operands +1.7976931348623157E308 * 1.7976931348623157E308 = Infinity, with double a[i] operands +1.7976931348623157E308 / 1.7976931348623157E308 = 1.0, with double a[i] operands +1.7976931348623157E308 + 1.7976931348623157E308 = Infinity, with double f(x) operands +1.7976931348623157E308 - 1.7976931348623157E308 = 0.0, with double f(x) operands +1.7976931348623157E308 * 1.7976931348623157E308 = Infinity, with double f(x) operands +1.7976931348623157E308 / 1.7976931348623157E308 = 1.0, with double f(x) operands +1.7976931348623157E308 + 1.7976931348623157E308 = Infinity, with double lExpr operands +1.7976931348623157E308 - 1.7976931348623157E308 = 0.0, with double lExpr operands +1.7976931348623157E308 * 1.7976931348623157E308 = Infinity, with double lExpr operands +1.7976931348623157E308 / 1.7976931348623157E308 = 1.0, with double lExpr operands +1.7976931348623157E308 + 1.7976931348623157E308 = Infinity, with double rExpr operands +1.7976931348623157E308 - 1.7976931348623157E308 = 0.0, with double rExpr operands +1.7976931348623157E308 * 1.7976931348623157E308 = Infinity, with double rExpr operands +1.7976931348623157E308 / 1.7976931348623157E308 = 1.0, with double rExpr operands +1.7976931348623157E308 + 1.7976931348623157E308 = Infinity, with double exprs operands +1.7976931348623157E308 - 1.7976931348623157E308 = 0.0, with double exprs operands +1.7976931348623157E308 * 1.7976931348623157E308 = Infinity, with double exprs operands +1.7976931348623157E308 / 1.7976931348623157E308 = 1.0, with double exprs operands +1.7976931348623157E308 + -4.9E-324 = 1.7976931348623157E308, with double param operands +1.7976931348623157E308 - -4.9E-324 = 1.7976931348623157E308, with double param operands +1.7976931348623157E308 * -4.9E-324 = -8.881784197001251E-16, with double param operands +1.7976931348623157E308 / -4.9E-324 = -Infinity, with double param operands +1.7976931348623157E308 + -4.9E-324 = 1.7976931348623157E308, with double local operands +1.7976931348623157E308 - -4.9E-324 = 1.7976931348623157E308, with double local operands +1.7976931348623157E308 * -4.9E-324 = -8.881784197001251E-16, with double local operands +1.7976931348623157E308 / -4.9E-324 = -Infinity, with double local operands +1.7976931348623157E308 + -4.9E-324 = 1.7976931348623157E308, with double static operands +1.7976931348623157E308 - -4.9E-324 = 1.7976931348623157E308, with double static operands +1.7976931348623157E308 * -4.9E-324 = -8.881784197001251E-16, with double static operands +1.7976931348623157E308 / -4.9E-324 = -Infinity, with double static operands +1.7976931348623157E308 + -4.9E-324 = 1.7976931348623157E308, with double field operands +1.7976931348623157E308 - -4.9E-324 = 1.7976931348623157E308, with double field operands +1.7976931348623157E308 * -4.9E-324 = -8.881784197001251E-16, with double field operands +1.7976931348623157E308 / -4.9E-324 = -Infinity, with double field operands +1.7976931348623157E308 + -4.9E-324 = 1.7976931348623157E308, with double a[i] operands +1.7976931348623157E308 - -4.9E-324 = 1.7976931348623157E308, with double a[i] operands +1.7976931348623157E308 * -4.9E-324 = -8.881784197001251E-16, with double a[i] operands +1.7976931348623157E308 / -4.9E-324 = -Infinity, with double a[i] operands +1.7976931348623157E308 + -4.9E-324 = 1.7976931348623157E308, with double f(x) operands +1.7976931348623157E308 - -4.9E-324 = 1.7976931348623157E308, with double f(x) operands +1.7976931348623157E308 * -4.9E-324 = -8.881784197001251E-16, with double f(x) operands +1.7976931348623157E308 / -4.9E-324 = -Infinity, with double f(x) operands +1.7976931348623157E308 + -4.9E-324 = 1.7976931348623157E308, with double lExpr operands +1.7976931348623157E308 - -4.9E-324 = 1.7976931348623157E308, with double lExpr operands +1.7976931348623157E308 * -4.9E-324 = -8.881784197001251E-16, with double lExpr operands +1.7976931348623157E308 / -4.9E-324 = -Infinity, with double lExpr operands +1.7976931348623157E308 + -4.9E-324 = 1.7976931348623157E308, with double rExpr operands +1.7976931348623157E308 - -4.9E-324 = 1.7976931348623157E308, with double rExpr operands +1.7976931348623157E308 * -4.9E-324 = -8.881784197001251E-16, with double rExpr operands +1.7976931348623157E308 / -4.9E-324 = -Infinity, with double rExpr operands +1.7976931348623157E308 + -4.9E-324 = 1.7976931348623157E308, with double exprs operands +1.7976931348623157E308 - -4.9E-324 = 1.7976931348623157E308, with double exprs operands +1.7976931348623157E308 * -4.9E-324 = -8.881784197001251E-16, with double exprs operands +1.7976931348623157E308 / -4.9E-324 = -Infinity, with double exprs operands +1.7976931348623157E308 + -1.7976931348623157E308 = 0.0, with double param operands +1.7976931348623157E308 - -1.7976931348623157E308 = Infinity, with double param operands +1.7976931348623157E308 * -1.7976931348623157E308 = -Infinity, with double param operands +1.7976931348623157E308 / -1.7976931348623157E308 = -1.0, with double param operands +1.7976931348623157E308 + -1.7976931348623157E308 = 0.0, with double local operands +1.7976931348623157E308 - -1.7976931348623157E308 = Infinity, with double local operands +1.7976931348623157E308 * -1.7976931348623157E308 = -Infinity, with double local operands +1.7976931348623157E308 / -1.7976931348623157E308 = -1.0, with double local operands +1.7976931348623157E308 + -1.7976931348623157E308 = 0.0, with double static operands +1.7976931348623157E308 - -1.7976931348623157E308 = Infinity, with double static operands +1.7976931348623157E308 * -1.7976931348623157E308 = -Infinity, with double static operands +1.7976931348623157E308 / -1.7976931348623157E308 = -1.0, with double static operands +1.7976931348623157E308 + -1.7976931348623157E308 = 0.0, with double field operands +1.7976931348623157E308 - -1.7976931348623157E308 = Infinity, with double field operands +1.7976931348623157E308 * -1.7976931348623157E308 = -Infinity, with double field operands +1.7976931348623157E308 / -1.7976931348623157E308 = -1.0, with double field operands +1.7976931348623157E308 + -1.7976931348623157E308 = 0.0, with double a[i] operands +1.7976931348623157E308 - -1.7976931348623157E308 = Infinity, with double a[i] operands +1.7976931348623157E308 * -1.7976931348623157E308 = -Infinity, with double a[i] operands +1.7976931348623157E308 / -1.7976931348623157E308 = -1.0, with double a[i] operands +1.7976931348623157E308 + -1.7976931348623157E308 = 0.0, with double f(x) operands +1.7976931348623157E308 - -1.7976931348623157E308 = Infinity, with double f(x) operands +1.7976931348623157E308 * -1.7976931348623157E308 = -Infinity, with double f(x) operands +1.7976931348623157E308 / -1.7976931348623157E308 = -1.0, with double f(x) operands +1.7976931348623157E308 + -1.7976931348623157E308 = 0.0, with double lExpr operands +1.7976931348623157E308 - -1.7976931348623157E308 = Infinity, with double lExpr operands +1.7976931348623157E308 * -1.7976931348623157E308 = -Infinity, with double lExpr operands +1.7976931348623157E308 / -1.7976931348623157E308 = -1.0, with double lExpr operands +1.7976931348623157E308 + -1.7976931348623157E308 = 0.0, with double rExpr operands +1.7976931348623157E308 - -1.7976931348623157E308 = Infinity, with double rExpr operands +1.7976931348623157E308 * -1.7976931348623157E308 = -Infinity, with double rExpr operands +1.7976931348623157E308 / -1.7976931348623157E308 = -1.0, with double rExpr operands +1.7976931348623157E308 + -1.7976931348623157E308 = 0.0, with double exprs operands +1.7976931348623157E308 - -1.7976931348623157E308 = Infinity, with double exprs operands +1.7976931348623157E308 * -1.7976931348623157E308 = -Infinity, with double exprs operands +1.7976931348623157E308 / -1.7976931348623157E308 = -1.0, with double exprs operands +1.7976931348623157E308 + -1.0 = 1.7976931348623157E308, with double param operands +1.7976931348623157E308 - -1.0 = 1.7976931348623157E308, with double param operands +1.7976931348623157E308 * -1.0 = -1.7976931348623157E308, with double param operands +1.7976931348623157E308 / -1.0 = -1.7976931348623157E308, with double param operands +1.7976931348623157E308 + -1.0 = 1.7976931348623157E308, with double local operands +1.7976931348623157E308 - -1.0 = 1.7976931348623157E308, with double local operands +1.7976931348623157E308 * -1.0 = -1.7976931348623157E308, with double local operands +1.7976931348623157E308 / -1.0 = -1.7976931348623157E308, with double local operands +1.7976931348623157E308 + -1.0 = 1.7976931348623157E308, with double static operands +1.7976931348623157E308 - -1.0 = 1.7976931348623157E308, with double static operands +1.7976931348623157E308 * -1.0 = -1.7976931348623157E308, with double static operands +1.7976931348623157E308 / -1.0 = -1.7976931348623157E308, with double static operands +1.7976931348623157E308 + -1.0 = 1.7976931348623157E308, with double field operands +1.7976931348623157E308 - -1.0 = 1.7976931348623157E308, with double field operands +1.7976931348623157E308 * -1.0 = -1.7976931348623157E308, with double field operands +1.7976931348623157E308 / -1.0 = -1.7976931348623157E308, with double field operands +1.7976931348623157E308 + -1.0 = 1.7976931348623157E308, with double a[i] operands +1.7976931348623157E308 - -1.0 = 1.7976931348623157E308, with double a[i] operands +1.7976931348623157E308 * -1.0 = -1.7976931348623157E308, with double a[i] operands +1.7976931348623157E308 / -1.0 = -1.7976931348623157E308, with double a[i] operands +1.7976931348623157E308 + -1.0 = 1.7976931348623157E308, with double f(x) operands +1.7976931348623157E308 - -1.0 = 1.7976931348623157E308, with double f(x) operands +1.7976931348623157E308 * -1.0 = -1.7976931348623157E308, with double f(x) operands +1.7976931348623157E308 / -1.0 = -1.7976931348623157E308, with double f(x) operands +1.7976931348623157E308 + -1.0 = 1.7976931348623157E308, with double lExpr operands +1.7976931348623157E308 - -1.0 = 1.7976931348623157E308, with double lExpr operands +1.7976931348623157E308 * -1.0 = -1.7976931348623157E308, with double lExpr operands +1.7976931348623157E308 / -1.0 = -1.7976931348623157E308, with double lExpr operands +1.7976931348623157E308 + -1.0 = 1.7976931348623157E308, with double rExpr operands +1.7976931348623157E308 - -1.0 = 1.7976931348623157E308, with double rExpr operands +1.7976931348623157E308 * -1.0 = -1.7976931348623157E308, with double rExpr operands +1.7976931348623157E308 / -1.0 = -1.7976931348623157E308, with double rExpr operands +1.7976931348623157E308 + -1.0 = 1.7976931348623157E308, with double exprs operands +1.7976931348623157E308 - -1.0 = 1.7976931348623157E308, with double exprs operands +1.7976931348623157E308 * -1.0 = -1.7976931348623157E308, with double exprs operands +1.7976931348623157E308 / -1.0 = -1.7976931348623157E308, with double exprs operands +1.7976931348623157E308 + 1.0 = 1.7976931348623157E308, with double param operands +1.7976931348623157E308 - 1.0 = 1.7976931348623157E308, with double param operands +1.7976931348623157E308 * 1.0 = 1.7976931348623157E308, with double param operands +1.7976931348623157E308 / 1.0 = 1.7976931348623157E308, with double param operands +1.7976931348623157E308 + 1.0 = 1.7976931348623157E308, with double local operands +1.7976931348623157E308 - 1.0 = 1.7976931348623157E308, with double local operands +1.7976931348623157E308 * 1.0 = 1.7976931348623157E308, with double local operands +1.7976931348623157E308 / 1.0 = 1.7976931348623157E308, with double local operands +1.7976931348623157E308 + 1.0 = 1.7976931348623157E308, with double static operands +1.7976931348623157E308 - 1.0 = 1.7976931348623157E308, with double static operands +1.7976931348623157E308 * 1.0 = 1.7976931348623157E308, with double static operands +1.7976931348623157E308 / 1.0 = 1.7976931348623157E308, with double static operands +1.7976931348623157E308 + 1.0 = 1.7976931348623157E308, with double field operands +1.7976931348623157E308 - 1.0 = 1.7976931348623157E308, with double field operands +1.7976931348623157E308 * 1.0 = 1.7976931348623157E308, with double field operands +1.7976931348623157E308 / 1.0 = 1.7976931348623157E308, with double field operands +1.7976931348623157E308 + 1.0 = 1.7976931348623157E308, with double a[i] operands +1.7976931348623157E308 - 1.0 = 1.7976931348623157E308, with double a[i] operands +1.7976931348623157E308 * 1.0 = 1.7976931348623157E308, with double a[i] operands +1.7976931348623157E308 / 1.0 = 1.7976931348623157E308, with double a[i] operands +1.7976931348623157E308 + 1.0 = 1.7976931348623157E308, with double f(x) operands +1.7976931348623157E308 - 1.0 = 1.7976931348623157E308, with double f(x) operands +1.7976931348623157E308 * 1.0 = 1.7976931348623157E308, with double f(x) operands +1.7976931348623157E308 / 1.0 = 1.7976931348623157E308, with double f(x) operands +1.7976931348623157E308 + 1.0 = 1.7976931348623157E308, with double lExpr operands +1.7976931348623157E308 - 1.0 = 1.7976931348623157E308, with double lExpr operands +1.7976931348623157E308 * 1.0 = 1.7976931348623157E308, with double lExpr operands +1.7976931348623157E308 / 1.0 = 1.7976931348623157E308, with double lExpr operands +1.7976931348623157E308 + 1.0 = 1.7976931348623157E308, with double rExpr operands +1.7976931348623157E308 - 1.0 = 1.7976931348623157E308, with double rExpr operands +1.7976931348623157E308 * 1.0 = 1.7976931348623157E308, with double rExpr operands +1.7976931348623157E308 / 1.0 = 1.7976931348623157E308, with double rExpr operands +1.7976931348623157E308 + 1.0 = 1.7976931348623157E308, with double exprs operands +1.7976931348623157E308 - 1.0 = 1.7976931348623157E308, with double exprs operands +1.7976931348623157E308 * 1.0 = 1.7976931348623157E308, with double exprs operands +1.7976931348623157E308 / 1.0 = 1.7976931348623157E308, with double exprs operands +1.7976931348623157E308 + -0.0 = 1.7976931348623157E308, with double param operands +1.7976931348623157E308 - -0.0 = 1.7976931348623157E308, with double param operands +1.7976931348623157E308 * -0.0 = -0.0, with double param operands +1.7976931348623157E308 / -0.0 = -Infinity, with double param operands +1.7976931348623157E308 + -0.0 = 1.7976931348623157E308, with double local operands +1.7976931348623157E308 - -0.0 = 1.7976931348623157E308, with double local operands +1.7976931348623157E308 * -0.0 = -0.0, with double local operands +1.7976931348623157E308 / -0.0 = -Infinity, with double local operands +1.7976931348623157E308 + -0.0 = 1.7976931348623157E308, with double static operands +1.7976931348623157E308 - -0.0 = 1.7976931348623157E308, with double static operands +1.7976931348623157E308 * -0.0 = -0.0, with double static operands +1.7976931348623157E308 / -0.0 = -Infinity, with double static operands +1.7976931348623157E308 + -0.0 = 1.7976931348623157E308, with double field operands +1.7976931348623157E308 - -0.0 = 1.7976931348623157E308, with double field operands +1.7976931348623157E308 * -0.0 = -0.0, with double field operands +1.7976931348623157E308 / -0.0 = -Infinity, with double field operands +1.7976931348623157E308 + -0.0 = 1.7976931348623157E308, with double a[i] operands +1.7976931348623157E308 - -0.0 = 1.7976931348623157E308, with double a[i] operands +1.7976931348623157E308 * -0.0 = -0.0, with double a[i] operands +1.7976931348623157E308 / -0.0 = -Infinity, with double a[i] operands +1.7976931348623157E308 + -0.0 = 1.7976931348623157E308, with double f(x) operands +1.7976931348623157E308 - -0.0 = 1.7976931348623157E308, with double f(x) operands +1.7976931348623157E308 * -0.0 = -0.0, with double f(x) operands +1.7976931348623157E308 / -0.0 = -Infinity, with double f(x) operands +1.7976931348623157E308 + -0.0 = 1.7976931348623157E308, with double lExpr operands +1.7976931348623157E308 - -0.0 = 1.7976931348623157E308, with double lExpr operands +1.7976931348623157E308 * -0.0 = -0.0, with double lExpr operands +1.7976931348623157E308 / -0.0 = -Infinity, with double lExpr operands +1.7976931348623157E308 + 0.0 = 1.7976931348623157E308, with double rExpr operands +1.7976931348623157E308 - 0.0 = 1.7976931348623157E308, with double rExpr operands +1.7976931348623157E308 * 0.0 = 0.0, with double rExpr operands +1.7976931348623157E308 / 0.0 = Infinity, with double rExpr operands +1.7976931348623157E308 + 0.0 = 1.7976931348623157E308, with double exprs operands +1.7976931348623157E308 - 0.0 = 1.7976931348623157E308, with double exprs operands +1.7976931348623157E308 * 0.0 = 0.0, with double exprs operands +1.7976931348623157E308 / 0.0 = Infinity, with double exprs operands +1.7976931348623157E308 + 0.0 = 1.7976931348623157E308, with double param operands +1.7976931348623157E308 - 0.0 = 1.7976931348623157E308, with double param operands +1.7976931348623157E308 * 0.0 = 0.0, with double param operands +1.7976931348623157E308 / 0.0 = Infinity, with double param operands +1.7976931348623157E308 + 0.0 = 1.7976931348623157E308, with double local operands +1.7976931348623157E308 - 0.0 = 1.7976931348623157E308, with double local operands +1.7976931348623157E308 * 0.0 = 0.0, with double local operands +1.7976931348623157E308 / 0.0 = Infinity, with double local operands +1.7976931348623157E308 + 0.0 = 1.7976931348623157E308, with double static operands +1.7976931348623157E308 - 0.0 = 1.7976931348623157E308, with double static operands +1.7976931348623157E308 * 0.0 = 0.0, with double static operands +1.7976931348623157E308 / 0.0 = Infinity, with double static operands +1.7976931348623157E308 + 0.0 = 1.7976931348623157E308, with double field operands +1.7976931348623157E308 - 0.0 = 1.7976931348623157E308, with double field operands +1.7976931348623157E308 * 0.0 = 0.0, with double field operands +1.7976931348623157E308 / 0.0 = Infinity, with double field operands +1.7976931348623157E308 + 0.0 = 1.7976931348623157E308, with double a[i] operands +1.7976931348623157E308 - 0.0 = 1.7976931348623157E308, with double a[i] operands +1.7976931348623157E308 * 0.0 = 0.0, with double a[i] operands +1.7976931348623157E308 / 0.0 = Infinity, with double a[i] operands +1.7976931348623157E308 + 0.0 = 1.7976931348623157E308, with double f(x) operands +1.7976931348623157E308 - 0.0 = 1.7976931348623157E308, with double f(x) operands +1.7976931348623157E308 * 0.0 = 0.0, with double f(x) operands +1.7976931348623157E308 / 0.0 = Infinity, with double f(x) operands +1.7976931348623157E308 + 0.0 = 1.7976931348623157E308, with double lExpr operands +1.7976931348623157E308 - 0.0 = 1.7976931348623157E308, with double lExpr operands +1.7976931348623157E308 * 0.0 = 0.0, with double lExpr operands +1.7976931348623157E308 / 0.0 = Infinity, with double lExpr operands +1.7976931348623157E308 + 0.0 = 1.7976931348623157E308, with double rExpr operands +1.7976931348623157E308 - 0.0 = 1.7976931348623157E308, with double rExpr operands +1.7976931348623157E308 * 0.0 = 0.0, with double rExpr operands +1.7976931348623157E308 / 0.0 = Infinity, with double rExpr operands +1.7976931348623157E308 + 0.0 = 1.7976931348623157E308, with double exprs operands +1.7976931348623157E308 - 0.0 = 1.7976931348623157E308, with double exprs operands +1.7976931348623157E308 * 0.0 = 0.0, with double exprs operands +1.7976931348623157E308 / 0.0 = Infinity, with double exprs operands +1.7976931348623157E308 + -Infinity = -Infinity, with double param operands +1.7976931348623157E308 - -Infinity = Infinity, with double param operands +1.7976931348623157E308 * -Infinity = -Infinity, with double param operands +1.7976931348623157E308 / -Infinity = -0.0, with double param operands +1.7976931348623157E308 + -Infinity = -Infinity, with double local operands +1.7976931348623157E308 - -Infinity = Infinity, with double local operands +1.7976931348623157E308 * -Infinity = -Infinity, with double local operands +1.7976931348623157E308 / -Infinity = -0.0, with double local operands +1.7976931348623157E308 + -Infinity = -Infinity, with double static operands +1.7976931348623157E308 - -Infinity = Infinity, with double static operands +1.7976931348623157E308 * -Infinity = -Infinity, with double static operands +1.7976931348623157E308 / -Infinity = -0.0, with double static operands +1.7976931348623157E308 + -Infinity = -Infinity, with double field operands +1.7976931348623157E308 - -Infinity = Infinity, with double field operands +1.7976931348623157E308 * -Infinity = -Infinity, with double field operands +1.7976931348623157E308 / -Infinity = -0.0, with double field operands +1.7976931348623157E308 + -Infinity = -Infinity, with double a[i] operands +1.7976931348623157E308 - -Infinity = Infinity, with double a[i] operands +1.7976931348623157E308 * -Infinity = -Infinity, with double a[i] operands +1.7976931348623157E308 / -Infinity = -0.0, with double a[i] operands +1.7976931348623157E308 + -Infinity = -Infinity, with double f(x) operands +1.7976931348623157E308 - -Infinity = Infinity, with double f(x) operands +1.7976931348623157E308 * -Infinity = -Infinity, with double f(x) operands +1.7976931348623157E308 / -Infinity = -0.0, with double f(x) operands +1.7976931348623157E308 + -Infinity = -Infinity, with double lExpr operands +1.7976931348623157E308 - -Infinity = Infinity, with double lExpr operands +1.7976931348623157E308 * -Infinity = -Infinity, with double lExpr operands +1.7976931348623157E308 / -Infinity = -0.0, with double lExpr operands +1.7976931348623157E308 + -Infinity = -Infinity, with double rExpr operands +1.7976931348623157E308 - -Infinity = Infinity, with double rExpr operands +1.7976931348623157E308 * -Infinity = -Infinity, with double rExpr operands +1.7976931348623157E308 / -Infinity = -0.0, with double rExpr operands +1.7976931348623157E308 + -Infinity = -Infinity, with double exprs operands +1.7976931348623157E308 - -Infinity = Infinity, with double exprs operands +1.7976931348623157E308 * -Infinity = -Infinity, with double exprs operands +1.7976931348623157E308 / -Infinity = -0.0, with double exprs operands +1.7976931348623157E308 + Infinity = Infinity, with double param operands +1.7976931348623157E308 - Infinity = -Infinity, with double param operands +1.7976931348623157E308 * Infinity = Infinity, with double param operands +1.7976931348623157E308 / Infinity = 0.0, with double param operands +1.7976931348623157E308 + Infinity = Infinity, with double local operands +1.7976931348623157E308 - Infinity = -Infinity, with double local operands +1.7976931348623157E308 * Infinity = Infinity, with double local operands +1.7976931348623157E308 / Infinity = 0.0, with double local operands +1.7976931348623157E308 + Infinity = Infinity, with double static operands +1.7976931348623157E308 - Infinity = -Infinity, with double static operands +1.7976931348623157E308 * Infinity = Infinity, with double static operands +1.7976931348623157E308 / Infinity = 0.0, with double static operands +1.7976931348623157E308 + Infinity = Infinity, with double field operands +1.7976931348623157E308 - Infinity = -Infinity, with double field operands +1.7976931348623157E308 * Infinity = Infinity, with double field operands +1.7976931348623157E308 / Infinity = 0.0, with double field operands +1.7976931348623157E308 + Infinity = Infinity, with double a[i] operands +1.7976931348623157E308 - Infinity = -Infinity, with double a[i] operands +1.7976931348623157E308 * Infinity = Infinity, with double a[i] operands +1.7976931348623157E308 / Infinity = 0.0, with double a[i] operands +1.7976931348623157E308 + Infinity = Infinity, with double f(x) operands +1.7976931348623157E308 - Infinity = -Infinity, with double f(x) operands +1.7976931348623157E308 * Infinity = Infinity, with double f(x) operands +1.7976931348623157E308 / Infinity = 0.0, with double f(x) operands +1.7976931348623157E308 + Infinity = Infinity, with double lExpr operands +1.7976931348623157E308 - Infinity = -Infinity, with double lExpr operands +1.7976931348623157E308 * Infinity = Infinity, with double lExpr operands +1.7976931348623157E308 / Infinity = 0.0, with double lExpr operands +1.7976931348623157E308 + Infinity = Infinity, with double rExpr operands +1.7976931348623157E308 - Infinity = -Infinity, with double rExpr operands +1.7976931348623157E308 * Infinity = Infinity, with double rExpr operands +1.7976931348623157E308 / Infinity = 0.0, with double rExpr operands +1.7976931348623157E308 + Infinity = Infinity, with double exprs operands +1.7976931348623157E308 - Infinity = -Infinity, with double exprs operands +1.7976931348623157E308 * Infinity = Infinity, with double exprs operands +1.7976931348623157E308 / Infinity = 0.0, with double exprs operands +1.7976931348623157E308 + NaN = NaN, with double param operands +1.7976931348623157E308 - NaN = NaN, with double param operands +1.7976931348623157E308 * NaN = NaN, with double param operands +1.7976931348623157E308 / NaN = NaN, with double param operands +1.7976931348623157E308 + NaN = NaN, with double local operands +1.7976931348623157E308 - NaN = NaN, with double local operands +1.7976931348623157E308 * NaN = NaN, with double local operands +1.7976931348623157E308 / NaN = NaN, with double local operands +1.7976931348623157E308 + NaN = NaN, with double static operands +1.7976931348623157E308 - NaN = NaN, with double static operands +1.7976931348623157E308 * NaN = NaN, with double static operands +1.7976931348623157E308 / NaN = NaN, with double static operands +1.7976931348623157E308 + NaN = NaN, with double field operands +1.7976931348623157E308 - NaN = NaN, with double field operands +1.7976931348623157E308 * NaN = NaN, with double field operands +1.7976931348623157E308 / NaN = NaN, with double field operands +1.7976931348623157E308 + NaN = NaN, with double a[i] operands +1.7976931348623157E308 - NaN = NaN, with double a[i] operands +1.7976931348623157E308 * NaN = NaN, with double a[i] operands +1.7976931348623157E308 / NaN = NaN, with double a[i] operands +1.7976931348623157E308 + NaN = NaN, with double f(x) operands +1.7976931348623157E308 - NaN = NaN, with double f(x) operands +1.7976931348623157E308 * NaN = NaN, with double f(x) operands +1.7976931348623157E308 / NaN = NaN, with double f(x) operands +1.7976931348623157E308 + NaN = NaN, with double lExpr operands +1.7976931348623157E308 - NaN = NaN, with double lExpr operands +1.7976931348623157E308 * NaN = NaN, with double lExpr operands +1.7976931348623157E308 / NaN = NaN, with double lExpr operands +1.7976931348623157E308 + NaN = NaN, with double rExpr operands +1.7976931348623157E308 - NaN = NaN, with double rExpr operands +1.7976931348623157E308 * NaN = NaN, with double rExpr operands +1.7976931348623157E308 / NaN = NaN, with double rExpr operands +1.7976931348623157E308 + NaN = NaN, with double exprs operands +1.7976931348623157E308 - NaN = NaN, with double exprs operands +1.7976931348623157E308 * NaN = NaN, with double exprs operands +1.7976931348623157E308 / NaN = NaN, with double exprs operands +-4.9E-324 + 4.9E-324 = 0.0, with double param operands +-4.9E-324 - 4.9E-324 = -1.0E-323, with double param operands +-4.9E-324 * 4.9E-324 = -0.0, with double param operands +-4.9E-324 / 4.9E-324 = -1.0, with double param operands +-4.9E-324 + 4.9E-324 = 0.0, with double local operands +-4.9E-324 - 4.9E-324 = -1.0E-323, with double local operands +-4.9E-324 * 4.9E-324 = -0.0, with double local operands +-4.9E-324 / 4.9E-324 = -1.0, with double local operands +-4.9E-324 + 4.9E-324 = 0.0, with double static operands +-4.9E-324 - 4.9E-324 = -1.0E-323, with double static operands +-4.9E-324 * 4.9E-324 = -0.0, with double static operands +-4.9E-324 / 4.9E-324 = -1.0, with double static operands +-4.9E-324 + 4.9E-324 = 0.0, with double field operands +-4.9E-324 - 4.9E-324 = -1.0E-323, with double field operands +-4.9E-324 * 4.9E-324 = -0.0, with double field operands +-4.9E-324 / 4.9E-324 = -1.0, with double field operands +-4.9E-324 + 4.9E-324 = 0.0, with double a[i] operands +-4.9E-324 - 4.9E-324 = -1.0E-323, with double a[i] operands +-4.9E-324 * 4.9E-324 = -0.0, with double a[i] operands +-4.9E-324 / 4.9E-324 = -1.0, with double a[i] operands +-4.9E-324 + 4.9E-324 = 0.0, with double f(x) operands +-4.9E-324 - 4.9E-324 = -1.0E-323, with double f(x) operands +-4.9E-324 * 4.9E-324 = -0.0, with double f(x) operands +-4.9E-324 / 4.9E-324 = -1.0, with double f(x) operands +-4.9E-324 + 4.9E-324 = 0.0, with double lExpr operands +-4.9E-324 - 4.9E-324 = -1.0E-323, with double lExpr operands +-4.9E-324 * 4.9E-324 = -0.0, with double lExpr operands +-4.9E-324 / 4.9E-324 = -1.0, with double lExpr operands +-4.9E-324 + 4.9E-324 = 0.0, with double rExpr operands +-4.9E-324 - 4.9E-324 = -1.0E-323, with double rExpr operands +-4.9E-324 * 4.9E-324 = -0.0, with double rExpr operands +-4.9E-324 / 4.9E-324 = -1.0, with double rExpr operands +-4.9E-324 + 4.9E-324 = 0.0, with double exprs operands +-4.9E-324 - 4.9E-324 = -1.0E-323, with double exprs operands +-4.9E-324 * 4.9E-324 = -0.0, with double exprs operands +-4.9E-324 / 4.9E-324 = -1.0, with double exprs operands +-4.9E-324 + 1.7976931348623157E308 = 1.7976931348623157E308, with double param operands +-4.9E-324 - 1.7976931348623157E308 = -1.7976931348623157E308, with double param operands +-4.9E-324 * 1.7976931348623157E308 = -8.881784197001251E-16, with double param operands +-4.9E-324 / 1.7976931348623157E308 = -0.0, with double param operands +-4.9E-324 + 1.7976931348623157E308 = 1.7976931348623157E308, with double local operands +-4.9E-324 - 1.7976931348623157E308 = -1.7976931348623157E308, with double local operands +-4.9E-324 * 1.7976931348623157E308 = -8.881784197001251E-16, with double local operands +-4.9E-324 / 1.7976931348623157E308 = -0.0, with double local operands +-4.9E-324 + 1.7976931348623157E308 = 1.7976931348623157E308, with double static operands +-4.9E-324 - 1.7976931348623157E308 = -1.7976931348623157E308, with double static operands +-4.9E-324 * 1.7976931348623157E308 = -8.881784197001251E-16, with double static operands +-4.9E-324 / 1.7976931348623157E308 = -0.0, with double static operands +-4.9E-324 + 1.7976931348623157E308 = 1.7976931348623157E308, with double field operands +-4.9E-324 - 1.7976931348623157E308 = -1.7976931348623157E308, with double field operands +-4.9E-324 * 1.7976931348623157E308 = -8.881784197001251E-16, with double field operands +-4.9E-324 / 1.7976931348623157E308 = -0.0, with double field operands +-4.9E-324 + 1.7976931348623157E308 = 1.7976931348623157E308, with double a[i] operands +-4.9E-324 - 1.7976931348623157E308 = -1.7976931348623157E308, with double a[i] operands +-4.9E-324 * 1.7976931348623157E308 = -8.881784197001251E-16, with double a[i] operands +-4.9E-324 / 1.7976931348623157E308 = -0.0, with double a[i] operands +-4.9E-324 + 1.7976931348623157E308 = 1.7976931348623157E308, with double f(x) operands +-4.9E-324 - 1.7976931348623157E308 = -1.7976931348623157E308, with double f(x) operands +-4.9E-324 * 1.7976931348623157E308 = -8.881784197001251E-16, with double f(x) operands +-4.9E-324 / 1.7976931348623157E308 = -0.0, with double f(x) operands +-4.9E-324 + 1.7976931348623157E308 = 1.7976931348623157E308, with double lExpr operands +-4.9E-324 - 1.7976931348623157E308 = -1.7976931348623157E308, with double lExpr operands +-4.9E-324 * 1.7976931348623157E308 = -8.881784197001251E-16, with double lExpr operands +-4.9E-324 / 1.7976931348623157E308 = -0.0, with double lExpr operands +-4.9E-324 + 1.7976931348623157E308 = 1.7976931348623157E308, with double rExpr operands +-4.9E-324 - 1.7976931348623157E308 = -1.7976931348623157E308, with double rExpr operands +-4.9E-324 * 1.7976931348623157E308 = -8.881784197001251E-16, with double rExpr operands +-4.9E-324