From 078afbceba891b368da15821daa525989fc8716d Mon Sep 17 00:00:00 2001
From: Farid Zakaria <fmzakari@google.com>
Date: Fri, 12 Jan 2024 18:59:02 +0000
Subject: [PATCH 01/22] ignore venv

---
 .gitignore | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.gitignore b/.gitignore
index 87620ac7..85dc1ceb 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1 +1,2 @@
 .ipynb_checkpoints/
+venv/

From 23c7fac4123f3e2e0ef9d442d4e51a96a31f658a Mon Sep 17 00:00:00 2001
From: Farid Zakaria <fmzakari@google.com>
Date: Sat, 20 Jan 2024 21:23:07 +0000
Subject: [PATCH 02/22] Added more to gitignore

---
 .gitignore | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.gitignore b/.gitignore
index 85dc1ceb..1f20486d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,3 @@
 .ipynb_checkpoints/
+**/__pycache__/
 venv/

From edcde3dbd2ef9fe8fd26ed3e71ce63fc35836906 Mon Sep 17 00:00:00 2001
From: Farid Zakaria <fmzakari@google.com>
Date: Sat, 20 Jan 2024 23:16:12 +0000
Subject: [PATCH 03/22] Minor fixes to engine.py for passing parent information
 for __pow__

---
 micrograd/engine.py | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/micrograd/engine.py b/micrograd/engine.py
index afd82cc5..f030faa6 100644
--- a/micrograd/engine.py
+++ b/micrograd/engine.py
@@ -1,4 +1,3 @@
-
 class Value:
     """ stores a single scalar value and its gradient """
 
@@ -34,7 +33,7 @@ def _backward():
 
     def __pow__(self, other):
         assert isinstance(other, (int, float)), "only supporting int/float powers for now"
-        out = Value(self.data**other, (self,), f'**{other}')
+        out = Value(self.data**other, (self, Value(other)), f'**{other}')
 
         def _backward():
             self.grad += (other * self.data**(other-1)) * out.grad
@@ -91,4 +90,4 @@ def __rtruediv__(self, other): # other / self
         return other * self**-1
 
     def __repr__(self):
-        return f"Value(data={self.data}, grad={self.grad})"
+        return f"Value(data={self.data}, grad={self.grad})"
\ No newline at end of file

From f1cab09aee912d0e4ee29d66d7bc3a5ca16f1113 Mon Sep 17 00:00:00 2001
From: Farid Zakaria <fmzakari@google.com>
Date: Sat, 20 Jan 2024 23:16:26 +0000
Subject: [PATCH 04/22] Add a visitor

---
 micrograd/visitor.py | 39 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 micrograd/visitor.py

diff --git a/micrograd/visitor.py b/micrograd/visitor.py
new file mode 100644
index 00000000..b245981b
--- /dev/null
+++ b/micrograd/visitor.py
@@ -0,0 +1,39 @@
+from micrograd.engine import Value
+import mlir.dialects.arith as arith
+import mlir.dialects.math as math
+import mlir.dialects.func as func
+from mlir.ir import Context, Location, InsertionPoint, Module
+from mlir import ir
+
+class MLIRVisitor:
+    
+    def __init__(self):
+        self.context = Context()
+        self.module  = Module.create(loc = Location.unknown(context = self.context))
+
+    def transform(self, value: Value) -> ir.Module:
+        with Context(), Location.unknown():
+            module  = Module.create()
+            with InsertionPoint(module.body):
+                @func.func()
+                def main():
+                    return arith.fptosi(ir.IntegerType.get_signless(32), self.walk(value))
+            return module
+        
+    def walk(self, value: Value):
+        match value._op:
+            case '':
+                return arith.constant(value = float(value.data), result = ir.F32Type.get())
+            case '*':
+                lhs, rhs = value._prev
+                return arith.mulf(self.walk(lhs), self.walk(rhs))
+            case '+':
+                lhs, rhs = value._prev
+                return arith.addf(self.walk(lhs), self.walk(rhs))
+            case 'ReLU':
+                (item,) = value._prev
+                return arith.maximumf(self.walk(Value(0.0)), self.walk(item))
+        if "**" in value._op:
+            base, exp = value._prev
+            return math.powf(self.walk(base), self.walk(exp))
+            
\ No newline at end of file

From b4cbbcdcc66538b7ae2da7de538fd2dc15ba0ace Mon Sep 17 00:00:00 2001
From: Farid Zakaria <fmzakari@google.com>
Date: Sat, 20 Jan 2024 23:16:47 +0000
Subject: [PATCH 05/22] Add a test visitor

---
 test/test_visitor.py | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 test/test_visitor.py

diff --git a/test/test_visitor.py b/test/test_visitor.py
new file mode 100644
index 00000000..4f2b4266
--- /dev/null
+++ b/test/test_visitor.py
@@ -0,0 +1,17 @@
+from micrograd.engine import Value
+from micrograd.visitor import MLIRVisitor
+# helps investigate segmentation faults
+import faulthandler
+faulthandler.enable()
+
+
+def test_basic_addition():
+    a = Value(4.0)
+    b = Value(2.0)
+    c = a + b
+    d = a + c
+    visitor = MLIRVisitor()
+    mlir_str = str(visitor.transform(d))
+    print(mlir_str)
+    # Hacky way to check we are producing any MLIR
+    assert len(mlir_str) > 0
\ No newline at end of file

From ff2593b53a6a2191344fcc518a12e554dd0eef24 Mon Sep 17 00:00:00 2001
From: Alexander Shaposhnikov <ashaposhnikov@google.com>
Date: Wed, 28 Feb 2024 22:49:39 +0000
Subject: [PATCH 06/22] Add test_mlir_execution.py

---
 micrograd/visitor.py        |  4 +--
 test/test_mlir_execution.py | 51 +++++++++++++++++++++++++++++++++++++
 2 files changed, 53 insertions(+), 2 deletions(-)
 create mode 100644 test/test_mlir_execution.py

diff --git a/micrograd/visitor.py b/micrograd/visitor.py
index b245981b..9d047474 100644
--- a/micrograd/visitor.py
+++ b/micrograd/visitor.py
@@ -17,7 +17,8 @@ def transform(self, value: Value) -> ir.Module:
             with InsertionPoint(module.body):
                 @func.func()
                 def main():
-                    return arith.fptosi(ir.IntegerType.get_signless(32), self.walk(value))
+                    return self.walk(value)
+                main.func_op.attributes["llvm.emit_c_interface"] = ir.UnitAttr.get()
             return module
         
     def walk(self, value: Value):
@@ -36,4 +37,3 @@ def walk(self, value: Value):
         if "**" in value._op:
             base, exp = value._prev
             return math.powf(self.walk(base), self.walk(exp))
-            
\ No newline at end of file
diff --git a/test/test_mlir_execution.py b/test/test_mlir_execution.py
new file mode 100644
index 00000000..f42caf2d
--- /dev/null
+++ b/test/test_mlir_execution.py
@@ -0,0 +1,51 @@
+from mlir.dialects.linalg.opdsl.lang import *
+from mlir.execution_engine import *
+from mlir.passmanager import *
+from mlir.dialects import linalg
+from mlir.dialects import func
+from mlir.dialects import builtin
+import sys
+import math
+import ctypes
+from micrograd.engine import Value
+from micrograd.visitor import MLIRVisitor
+# helps investigate segmentation faults
+import faulthandler
+faulthandler.enable()
+
+
+def transform(mod):
+    pm = PassManager("builtin.module", context=mod.context)
+    pm.add("func.func(convert-linalg-to-loops)")
+    pm.add("func.func(lower-affine)")
+    pm.add("func.func(convert-math-to-llvm)")
+    pm.add("func.func(convert-scf-to-cf)")
+    pm.add("func.func(arith-expand)")
+    pm.add("func.func(memref-expand)")
+    pm.add("convert-vector-to-llvm")
+    pm.add("finalize-memref-to-llvm")
+    pm.add("convert-func-to-llvm")
+    pm.add("reconcile-unrealized-casts")
+    pm.run(mod.operation)
+    return mod
+
+
+def test_basic_addition():
+    a = Value(4.0)
+    b = Value(2.0)
+    c = a + b  # 6.
+    d = a + c  # 10.
+    visitor = MLIRVisitor()
+    mlir_module = visitor.transform(d)
+    mlir_str = str(mlir_module)
+    print(mlir_str)
+    # Hacky way to check we are producing any MLIR
+    assert len(mlir_str) > 0
+    transformed_mlir_module = transform(mlir_module)
+    print(transformed_mlir_module)
+    execution_engine = ExecutionEngine(transformed_mlir_module)
+    c_float_p = ctypes.c_float * 1
+    res = c_float_p(-1.0)
+    execution_engine.invoke("main", res)
+    print(res[0])
+    assert math.isclose(10., res[0], abs_tol=1e-08)

From 621328a3eaf3101766374f59b04f3a8fba272254 Mon Sep 17 00:00:00 2001
From: Alexander Shaposhnikov <ashaposhnikov@google.com>
Date: Wed, 28 Feb 2024 23:21:40 +0000
Subject: [PATCH 07/22] Simplify the pipeline

---
 test/test_mlir_execution.py | 11 +----------
 1 file changed, 1 insertion(+), 10 deletions(-)

diff --git a/test/test_mlir_execution.py b/test/test_mlir_execution.py
index f42caf2d..74ee68a7 100644
--- a/test/test_mlir_execution.py
+++ b/test/test_mlir_execution.py
@@ -16,16 +16,7 @@
 
 def transform(mod):
     pm = PassManager("builtin.module", context=mod.context)
-    pm.add("func.func(convert-linalg-to-loops)")
-    pm.add("func.func(lower-affine)")
-    pm.add("func.func(convert-math-to-llvm)")
-    pm.add("func.func(convert-scf-to-cf)")
-    pm.add("func.func(arith-expand)")
-    pm.add("func.func(memref-expand)")
-    pm.add("convert-vector-to-llvm")
-    pm.add("finalize-memref-to-llvm")
-    pm.add("convert-func-to-llvm")
-    pm.add("reconcile-unrealized-casts")
+    pm.add("convert-to-llvm")
     pm.run(mod.operation)
     return mod
 

From 25138a095fdb4b042e1044992ac91fbfb8d2ff03 Mon Sep 17 00:00:00 2001
From: Alexander Shaposhnikov <ashaposhnikov@google.com>
Date: Thu, 29 Feb 2024 08:42:27 +0000
Subject: [PATCH 08/22] Add jit.py, test_jit.py

---
 micrograd/jit.py            | 98 +++++++++++++++++++++++++++++++++++++
 micrograd/visitor.py        | 39 ---------------
 test/test_jit.py            | 51 +++++++++++++++++++
 test/test_mlir_execution.py | 42 ----------------
 test/test_visitor.py        | 17 -------
 5 files changed, 149 insertions(+), 98 deletions(-)
 create mode 100644 micrograd/jit.py
 delete mode 100644 micrograd/visitor.py
 create mode 100644 test/test_jit.py
 delete mode 100644 test/test_mlir_execution.py
 delete mode 100644 test/test_visitor.py

diff --git a/micrograd/jit.py b/micrograd/jit.py
new file mode 100644
index 00000000..f52a756f
--- /dev/null
+++ b/micrograd/jit.py
@@ -0,0 +1,98 @@
+from micrograd.engine import Value
+from micrograd.nn import Neuron, Layer, MLP
+import mlir.dialects.arith as arith
+import mlir.dialects.math as math
+import mlir.dialects.func as func
+from mlir.ir import Context, Location, InsertionPoint, Module
+from mlir.execution_engine import ExecutionEngine
+from mlir.passmanager import PassManager
+from mlir import ir
+import sys
+from typing import Union
+import math
+import ctypes
+import random
+
+
+class Compiler:
+    def __init__(self, compiled_values={}):
+        self.compiled_values = compiled_values
+
+    def walk(self, value: Value):
+        if value in self.compiled_values:
+            return self.compiled_values[value]
+        match value._op:
+            case '':
+                return arith.constant(
+                    value=float(
+                        value.data),
+                    result=ir.F32Type.get())
+            case '*':
+                lhs, rhs = value._prev
+                return arith.mulf(self.walk(lhs), self.walk(rhs))
+            case '+':
+                lhs, rhs = value._prev
+                return arith.addf(self.walk(lhs), self.walk(rhs))
+            case 'ReLU':
+                (item,) = value._prev
+                return arith.maximumf(self.walk(Value(0.0)), self.walk(item))
+        if "**" in value._op:
+            base, exp = value._prev
+            return math.powf(self.walk(base), self.walk(exp))
+
+
+def _get_args_num(net: Union[Value, Neuron, Layer, MLP]) -> int:
+    if isinstance(net, Neuron):
+        return len(net.parameters()) - 1
+    if isinstance(net, Layer):
+        return _get_args_num(net.neurons[0])
+    if isinstance(net, MLP):
+        return _get_args_num(net.layers[0])
+    assert isinstance(net, Value)
+    return 0
+
+
+def _compile(net: Union[Value, Neuron, Layer, MLP]):
+    args_num = _get_args_num(net)
+    args_types = [ir.F32Type.get()] * args_num
+    args_values = [Value(0) for _ in range(args_num)]
+
+    @func.func(*args_types)
+    def main(*args):
+        net_value = net if isinstance(net, Value) else net(args_values)
+        compiled_values = {v: cv for v, cv in zip(args_values, args)}
+        compiler = Compiler(compiled_values)
+        if isinstance(net_value, list):
+            return [compiler.walk(value) for value in net_value]
+        return compiler.walk(net_value)
+    main.func_op.attributes["llvm.emit_c_interface"] = ir.UnitAttr.get()
+
+
+def _compile_standalone(
+        net: Union[Value, Neuron, Layer, MLP]) -> ir.Module:
+    with Context(), Location.unknown():
+        module = Module.create()
+        with InsertionPoint(module.body):
+            _compile(net)
+        return module
+
+
+def _transform(mod):
+    pm = PassManager("builtin.module", context=mod.context)
+    pm.add("convert-to-llvm")
+    pm.run(mod.operation)
+    return mod
+
+
+def jit(net: Union[Value, Neuron, Layer, MLP]):
+    m = _compile_standalone(net)
+    execution_engine = ExecutionEngine(_transform(m))
+
+    def jitted_net(x=None):
+        c_float_p = ctypes.c_float * 1
+        xs = [] if isinstance(net, Value) else x
+        args = [c_float_p(v) for v in xs]
+        res = c_float_p(-1.0)
+        execution_engine.invoke("main", *args, res)
+        return res[0]
+    return jitted_net
diff --git a/micrograd/visitor.py b/micrograd/visitor.py
deleted file mode 100644
index 9d047474..00000000
--- a/micrograd/visitor.py
+++ /dev/null
@@ -1,39 +0,0 @@
-from micrograd.engine import Value
-import mlir.dialects.arith as arith
-import mlir.dialects.math as math
-import mlir.dialects.func as func
-from mlir.ir import Context, Location, InsertionPoint, Module
-from mlir import ir
-
-class MLIRVisitor:
-    
-    def __init__(self):
-        self.context = Context()
-        self.module  = Module.create(loc = Location.unknown(context = self.context))
-
-    def transform(self, value: Value) -> ir.Module:
-        with Context(), Location.unknown():
-            module  = Module.create()
-            with InsertionPoint(module.body):
-                @func.func()
-                def main():
-                    return self.walk(value)
-                main.func_op.attributes["llvm.emit_c_interface"] = ir.UnitAttr.get()
-            return module
-        
-    def walk(self, value: Value):
-        match value._op:
-            case '':
-                return arith.constant(value = float(value.data), result = ir.F32Type.get())
-            case '*':
-                lhs, rhs = value._prev
-                return arith.mulf(self.walk(lhs), self.walk(rhs))
-            case '+':
-                lhs, rhs = value._prev
-                return arith.addf(self.walk(lhs), self.walk(rhs))
-            case 'ReLU':
-                (item,) = value._prev
-                return arith.maximumf(self.walk(Value(0.0)), self.walk(item))
-        if "**" in value._op:
-            base, exp = value._prev
-            return math.powf(self.walk(base), self.walk(exp))
diff --git a/test/test_jit.py b/test/test_jit.py
new file mode 100644
index 00000000..46f3dcd8
--- /dev/null
+++ b/test/test_jit.py
@@ -0,0 +1,51 @@
+import sys
+import math
+import ctypes
+import random
+from micrograd.engine import Value
+from micrograd.nn import Neuron, Layer, MLP
+from micrograd.jit import jit
+# helps investigate segmentation faults
+import faulthandler
+faulthandler.enable()
+
+
+def test_value():
+    a = Value(4.0)
+    b = Value(2.0)
+    c = a + b  # 6.
+    d = a + c  # 10.
+    jd = jit(d)
+    assert math.isclose(10., jd(), abs_tol=1e-04)
+
+
+def test_neuron():
+    n = Neuron(nin=1, nonlin=False)
+    n.w = [2.]
+    jn = jit(n)
+    args = [10.0]
+    assert math.isclose(20., jn(args), abs_tol=1e-04)
+
+
+def test_layer():
+    random.seed(10)
+    l = Layer(nin=2, nout=1)
+    jl = jit(l)
+    args = [-30., -20.]
+    assert math.isclose(l(args).data, jl(args), abs_tol=1e-04)
+
+
+def test_mlp():
+    random.seed(10)
+    nn = MLP(nin=2, nouts=[1])
+    jnn = jit(nn)
+    args = [-30., -20.]
+    assert math.isclose(nn(args).data, jnn(args), abs_tol=1e-04)
+
+
+def test_mlp_complex():
+    random.seed(10)
+    nn = MLP(nin=2, nouts=[2, 1])
+    jnn = jit(nn)
+    args = [-30., -20.]
+    assert math.isclose(nn(args).data, jnn(args), abs_tol=1e-04)
diff --git a/test/test_mlir_execution.py b/test/test_mlir_execution.py
deleted file mode 100644
index 74ee68a7..00000000
--- a/test/test_mlir_execution.py
+++ /dev/null
@@ -1,42 +0,0 @@
-from mlir.dialects.linalg.opdsl.lang import *
-from mlir.execution_engine import *
-from mlir.passmanager import *
-from mlir.dialects import linalg
-from mlir.dialects import func
-from mlir.dialects import builtin
-import sys
-import math
-import ctypes
-from micrograd.engine import Value
-from micrograd.visitor import MLIRVisitor
-# helps investigate segmentation faults
-import faulthandler
-faulthandler.enable()
-
-
-def transform(mod):
-    pm = PassManager("builtin.module", context=mod.context)
-    pm.add("convert-to-llvm")
-    pm.run(mod.operation)
-    return mod
-
-
-def test_basic_addition():
-    a = Value(4.0)
-    b = Value(2.0)
-    c = a + b  # 6.
-    d = a + c  # 10.
-    visitor = MLIRVisitor()
-    mlir_module = visitor.transform(d)
-    mlir_str = str(mlir_module)
-    print(mlir_str)
-    # Hacky way to check we are producing any MLIR
-    assert len(mlir_str) > 0
-    transformed_mlir_module = transform(mlir_module)
-    print(transformed_mlir_module)
-    execution_engine = ExecutionEngine(transformed_mlir_module)
-    c_float_p = ctypes.c_float * 1
-    res = c_float_p(-1.0)
-    execution_engine.invoke("main", res)
-    print(res[0])
-    assert math.isclose(10., res[0], abs_tol=1e-08)
diff --git a/test/test_visitor.py b/test/test_visitor.py
deleted file mode 100644
index 4f2b4266..00000000
--- a/test/test_visitor.py
+++ /dev/null
@@ -1,17 +0,0 @@
-from micrograd.engine import Value
-from micrograd.visitor import MLIRVisitor
-# helps investigate segmentation faults
-import faulthandler
-faulthandler.enable()
-
-
-def test_basic_addition():
-    a = Value(4.0)
-    b = Value(2.0)
-    c = a + b
-    d = a + c
-    visitor = MLIRVisitor()
-    mlir_str = str(visitor.transform(d))
-    print(mlir_str)
-    # Hacky way to check we are producing any MLIR
-    assert len(mlir_str) > 0
\ No newline at end of file

From fc6c0961a5f36605e1cce55e69083d9fea3cfec9 Mon Sep 17 00:00:00 2001
From: Farid Zakaria <fmzakari@google.com>
Date: Thu, 29 Feb 2024 17:12:25 +0000
Subject: [PATCH 09/22] Add direnv integration

---
 .envrc     | 1 +
 .gitignore | 1 +
 2 files changed, 2 insertions(+)
 create mode 100644 .envrc

diff --git a/.envrc b/.envrc
new file mode 100644
index 00000000..4e46a90c
--- /dev/null
+++ b/.envrc
@@ -0,0 +1 @@
+layout python3
\ No newline at end of file
diff --git a/.gitignore b/.gitignore
index 1f20486d..aa0b7bf8 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,4 @@
 .ipynb_checkpoints/
 **/__pycache__/
 venv/
+.direnv/

From b27f24df3e5b8f13fc98adb0f23216bfa9d0153a Mon Sep 17 00:00:00 2001
From: Farid Zakaria <fmzakari@google.com>
Date: Thu, 29 Feb 2024 17:30:40 +0000
Subject: [PATCH 10/22] Add requirements.txt file

---
 README.md        |  8 ++++++++
 requirements.txt | 28 ++++++++++++++++++++++++++++
 2 files changed, 36 insertions(+)
 create mode 100644 requirements.txt

diff --git a/README.md b/README.md
index 931f4d77..1c912952 100644
--- a/README.md
+++ b/README.md
@@ -64,6 +64,14 @@ To run the unit tests you will have to install [PyTorch](https://pytorch.org/),
 python -m pytest
 ```
 
+### Dependencies
+
+There is a `requirements.txt` with the necessary dependencies.
+
+```bash
+pip install -r requirements.txt
+```
+
 ### License
 
 MIT
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 00000000..b95307f1
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,28 @@
+filelock==3.13.1
+fsspec==2024.2.0
+iniconfig==2.0.0
+Jinja2==3.1.3
+MarkupSafe==2.1.5
+--find-links https://makslevental.github.io/wheels
+mlir-python-bindings==19.0.0.2024022901+vulkan.0fe4b9da
+mpmath==1.3.0
+networkx==3.2.1
+nvidia-cublas-cu12==12.1.3.1
+nvidia-cuda-cupti-cu12==12.1.105
+nvidia-cuda-nvrtc-cu12==12.1.105
+nvidia-cuda-runtime-cu12==12.1.105
+nvidia-cudnn-cu12==8.9.2.26
+nvidia-cufft-cu12==11.0.2.54
+nvidia-curand-cu12==10.3.2.106
+nvidia-cusolver-cu12==11.4.5.107
+nvidia-cusparse-cu12==12.1.0.106
+nvidia-nccl-cu12==2.19.3
+nvidia-nvjitlink-cu12==12.3.101
+nvidia-nvtx-cu12==12.1.105
+packaging==23.2
+pluggy==1.4.0
+pytest==8.0.2
+sympy==1.12
+torch==2.2.1
+triton==2.2.0
+typing_extensions==4.10.0

From 518e151e26dd38ffbee9030b86e253de25edfb60 Mon Sep 17 00:00:00 2001
From: Farid Zakaria <fmzakari@google.com>
Date: Thu, 29 Feb 2024 17:32:57 +0000
Subject: [PATCH 11/22] Added numpy to requirements

---
 requirements.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/requirements.txt b/requirements.txt
index b95307f1..df33cbda 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -7,6 +7,7 @@ MarkupSafe==2.1.5
 mlir-python-bindings==19.0.0.2024022901+vulkan.0fe4b9da
 mpmath==1.3.0
 networkx==3.2.1
+numpy==1.26.4
 nvidia-cublas-cu12==12.1.3.1
 nvidia-cuda-cupti-cu12==12.1.105
 nvidia-cuda-nvrtc-cu12==12.1.105

From 440f14a7e498a0993d58ebe740fb18ae362dac6c Mon Sep 17 00:00:00 2001
From: Farid Zakaria <fmzakari@google.com>
Date: Thu, 29 Feb 2024 17:35:26 +0000
Subject: [PATCH 12/22] Add __init__.py to test directory

---
 test/__init__.py | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 test/__init__.py

diff --git a/test/__init__.py b/test/__init__.py
new file mode 100644
index 00000000..e69de29b

From 0bfcaf362d21db7110863f00ec9bde2949075ea6 Mon Sep 17 00:00:00 2001
From: Farid Zakaria <fmzakari@google.com>
Date: Thu, 29 Feb 2024 17:43:54 +0000
Subject: [PATCH 13/22] Fixup some tests to test against non JIT

---
 test/test_jit.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/test_jit.py b/test/test_jit.py
index 46f3dcd8..edce825f 100644
--- a/test/test_jit.py
+++ b/test/test_jit.py
@@ -16,7 +16,7 @@ def test_value():
     c = a + b  # 6.
     d = a + c  # 10.
     jd = jit(d)
-    assert math.isclose(10., jd(), abs_tol=1e-04)
+    assert math.isclose(d.data, jd(), abs_tol=1e-04)
 
 
 def test_neuron():
@@ -24,7 +24,7 @@ def test_neuron():
     n.w = [2.]
     jn = jit(n)
     args = [10.0]
-    assert math.isclose(20., jn(args), abs_tol=1e-04)
+    assert math.isclose(n(args).data, jn(args), abs_tol=1e-04)
 
 
 def test_layer():

From 2213aea4d1a503f50182c88666dfec47cbfb73dd Mon Sep 17 00:00:00 2001
From: Farid Zakaria <fmzakari@google.com>
Date: Thu, 29 Feb 2024 18:00:20 +0000
Subject: [PATCH 14/22] Changed README for how to invoke pytest

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 1c912952..474199f5 100644
--- a/README.md
+++ b/README.md
@@ -61,7 +61,7 @@ dot = draw_dot(y)
 To run the unit tests you will have to install [PyTorch](https://pytorch.org/), which the tests use as a reference for verifying the correctness of the calculated gradients. Then simply:
 
 ```bash
-python -m pytest
+pytest
 ```
 
 ### Dependencies

From 84cb5557182254d6656f4aa2dd108baf822d256d Mon Sep 17 00:00:00 2001
From: Farid Zakaria <fmzakari@google.com>
Date: Thu, 29 Feb 2024 18:00:39 +0000
Subject: [PATCH 15/22] Added a JIT callable to print mlir

---
 micrograd/jit.py | 59 +++++++++++++++++++++++++++++++-----------------
 1 file changed, 38 insertions(+), 21 deletions(-)

diff --git a/micrograd/jit.py b/micrograd/jit.py
index f52a756f..d044c698 100644
--- a/micrograd/jit.py
+++ b/micrograd/jit.py
@@ -7,33 +7,30 @@
 from mlir.execution_engine import ExecutionEngine
 from mlir.passmanager import PassManager
 from mlir import ir
-import sys
 from typing import Union
 import math
 import ctypes
-import random
 
 
 class Compiler:
+    """Compile a micrograd computation Value graph to MLIR arithmetic dialect."""
+
     def __init__(self, compiled_values={}):
         self.compiled_values = compiled_values
 
-    def walk(self, value: Value):
+    def walk(self, value: Value) -> ir.Value:
         if value in self.compiled_values:
             return self.compiled_values[value]
         match value._op:
-            case '':
-                return arith.constant(
-                    value=float(
-                        value.data),
-                    result=ir.F32Type.get())
-            case '*':
+            case "":
+                return arith.constant(value=float(value.data), result=ir.F32Type.get())
+            case "*":
                 lhs, rhs = value._prev
                 return arith.mulf(self.walk(lhs), self.walk(rhs))
-            case '+':
+            case "+":
                 lhs, rhs = value._prev
                 return arith.addf(self.walk(lhs), self.walk(rhs))
-            case 'ReLU':
+            case "ReLU":
                 (item,) = value._prev
                 return arith.maximumf(self.walk(Value(0.0)), self.walk(item))
         if "**" in value._op:
@@ -65,11 +62,11 @@ def main(*args):
         if isinstance(net_value, list):
             return [compiler.walk(value) for value in net_value]
         return compiler.walk(net_value)
+
     main.func_op.attributes["llvm.emit_c_interface"] = ir.UnitAttr.get()
 
 
-def _compile_standalone(
-        net: Union[Value, Neuron, Layer, MLP]) -> ir.Module:
+def _compile_standalone(net: Union[Value, Neuron, Layer, MLP]) -> ir.Module:
     with Context(), Location.unknown():
         module = Module.create()
         with InsertionPoint(module.body):
@@ -77,22 +74,42 @@ def _compile_standalone(
         return module
 
 
-def _transform(mod):
+def _lower_to_llvm(mod: ir.Module) -> ir.Module:
+    """Lower the MLIR module to LLVM.
+
+    The assumption is that the module only uses standard
+    dialects that can be lowered to LLVM.
+    """
     pm = PassManager("builtin.module", context=mod.context)
     pm.add("convert-to-llvm")
     pm.run(mod.operation)
     return mod
 
 
-def jit(net: Union[Value, Neuron, Layer, MLP]):
-    m = _compile_standalone(net)
-    execution_engine = ExecutionEngine(_transform(m))
+class JittedNet:
+    def __init__(
+        self,
+        net: Union[Value, Neuron, Layer, MLP],
+        m: ir.Module,
+        execution_engine: ExecutionEngine,
+    ):
+        self.net = net
+        self.m = m
+        self.execution_engine = execution_engine
 
-    def jitted_net(x=None):
+    def __call__(self, x=None):
         c_float_p = ctypes.c_float * 1
-        xs = [] if isinstance(net, Value) else x
+        xs = [] if isinstance(self.net, Value) else x
         args = [c_float_p(v) for v in xs]
         res = c_float_p(-1.0)
-        execution_engine.invoke("main", *args, res)
+        self.execution_engine.invoke("main", *args, res)
         return res[0]
-    return jitted_net
+
+    def __str__(self):
+        return str(self.m)
+
+
+def jit(net: Union[Value, Neuron, Layer, MLP]):
+    m = _compile_standalone(net)
+    execution_engine = ExecutionEngine(_lower_to_llvm(m))
+    return JittedNet(net, m, execution_engine)
\ No newline at end of file

From 87489d70056933e913f1d00c44fc8fd340cff0a9 Mon Sep 17 00:00:00 2001
From: Farid Zakaria <fmzakari@google.com>
Date: Thu, 29 Feb 2024 18:33:34 +0000
Subject: [PATCH 16/22] Refinements

* Added JIT doc to README
* Added more comments
* Cleaned up ctypes code
---
 README.md        | 45 +++++++++++++++++++++++++++++++++++++++++++++
 micrograd/jit.py | 34 +++++++++++++++++++++-------------
 test/test_jit.py |  2 --
 3 files changed, 66 insertions(+), 15 deletions(-)

diff --git a/README.md b/README.md
index 474199f5..dbd68ff3 100644
--- a/README.md
+++ b/README.md
@@ -72,6 +72,51 @@ There is a `requirements.txt` with the necessary dependencies.
 pip install -r requirements.txt
 ```
 
+### Just in Time Compilation
+
+This repository also contains a JIT compiler for the micrograd engine using [mlir](https://mlir.llvm.org/) which is then lowered to LLVM IR and executed with a provided
+CPU backend.
+
+```python
+def test_value():
+    a = Value(4.0)
+    b = Value(2.0)
+    c = a + b  # 6.
+    d = a + c  # 10.
+    jd = jit(d)
+    assert math.isclose(d.data, jd(), abs_tol=1e-04)
+
+def test_mlp():
+    random.seed(10)
+    nn = MLP(nin=2, nouts=[1])
+    jnn = jit(nn)
+    args = [-30., -20.]
+    assert math.isclose(nn(args).data, jnn(args), abs_tol=1e-04)
+```
+
+You can also print the JIT object returned to see the corresponding MLIR IR.
+```python
+>>> from micrograd.engine import Value
+>>> from micrograd.jit import jit
+>>> a = Value(4.0)
+>>> b = Value(2.0)
+>>> c = a + b
+>>> jit_c = jit(c)
+>>> print(jit_c)
+module {
+  llvm.func @main() -> f32 attributes {llvm.emit_c_interface} {
+    %0 = llvm.mlir.constant(4.000000e+00 : f32) : f32
+    %1 = llvm.mlir.constant(2.000000e+00 : f32) : f32
+    %2 = llvm.mlir.constant(6.000000e+00 : f32) : f32
+    llvm.return %2 : f32
+  }
+  llvm.func @_mlir_ciface_main() -> f32 attributes {llvm.emit_c_interface} {
+    %0 = llvm.call @main() : () -> f32
+    llvm.return %0 : f32
+  }
+}
+```
+
 ### License
 
 MIT
diff --git a/micrograd/jit.py b/micrograd/jit.py
index d044c698..408dd394 100644
--- a/micrograd/jit.py
+++ b/micrograd/jit.py
@@ -7,18 +7,20 @@
 from mlir.execution_engine import ExecutionEngine
 from mlir.passmanager import PassManager
 from mlir import ir
-from typing import Union
+from typing import Union, Optional
 import math
-import ctypes
+from ctypes import c_float, byref
 
 
 class Compiler:
-    """Compile a micrograd computation Value graph to MLIR arithmetic dialect."""
+    """Compiler for a micrograd computation Value graph to MLIR arithmetic dialect."""
 
     def __init__(self, compiled_values={}):
         self.compiled_values = compiled_values
 
     def walk(self, value: Value) -> ir.Value:
+        """Walk the Value graph and convert it an isomorphic MLIR arithmetic dialect graph."""
+
         if value in self.compiled_values:
             return self.compiled_values[value]
         match value._op:
@@ -80,8 +82,7 @@ def _lower_to_llvm(mod: ir.Module) -> ir.Module:
     The assumption is that the module only uses standard
     dialects that can be lowered to LLVM.
     """
-    pm = PassManager("builtin.module", context=mod.context)
-    pm.add("convert-to-llvm")
+    pm = PassManager.parse("builtin.module(convert-to-llvm)", context=mod.context)
     pm.run(mod.operation)
     return mod
 
@@ -97,19 +98,26 @@ def __init__(
         self.m = m
         self.execution_engine = execution_engine
 
-    def __call__(self, x=None):
-        c_float_p = ctypes.c_float * 1
+    def __call__(self, x: Optional[list[float]] = None):
+        if isinstance(self.net, Value) and x != None:
+            raise "You should not pass any arguments to a Value."
         xs = [] if isinstance(self.net, Value) else x
-        args = [c_float_p(v) for v in xs]
-        res = c_float_p(-1.0)
-        self.execution_engine.invoke("main", *args, res)
-        return res[0]
+        args = [byref(c_float(v)) for v in xs]
+        res = c_float(-1.0)
+        self.execution_engine.invoke("main", *args, byref(res))
+        return res.value
 
     def __str__(self):
         return str(self.m)
 
 
-def jit(net: Union[Value, Neuron, Layer, MLP]):
+def jit(net: Union[Value, Neuron, Layer, MLP]) -> JittedNet:
+    """Given a micrograd computation graph, compile it to MLIR and then to LLVM.
+
+    You can also print the returned object to see the MLIR module.
+
+    @return: a callable that takes the input arguments of the computation graph
+    """
     m = _compile_standalone(net)
     execution_engine = ExecutionEngine(_lower_to_llvm(m))
-    return JittedNet(net, m, execution_engine)
\ No newline at end of file
+    return JittedNet(net, m, execution_engine)
diff --git a/test/test_jit.py b/test/test_jit.py
index edce825f..abb2c17d 100644
--- a/test/test_jit.py
+++ b/test/test_jit.py
@@ -1,6 +1,4 @@
-import sys
 import math
-import ctypes
 import random
 from micrograd.engine import Value
 from micrograd.nn import Neuron, Layer, MLP

From 0082cc01a76ef5b5df5532c57b4ddc80bc7e6869 Mon Sep 17 00:00:00 2001
From: Farid Zakaria <fmzakari@google.com>
Date: Fri, 1 Mar 2024 00:40:54 +0000
Subject: [PATCH 17/22] Fix it so that JIT works for multiple out NN

* Crazy amount of debugging to fix this. Alexander went crazy deep to
  look at the instructions in lldb to see that the MLIR CPU runner was
  doing a double dereference only when the return is a list.

  The argument is also first in the method list ... why!?

Co-authored-by: Alexander Shaposhnikov <ashaposhnikov@google.com>
---
 micrograd/jit.py | 27 +++++++++++++++++++++++----
 test/test_jit.py | 19 ++++++++++++++++++-
 2 files changed, 41 insertions(+), 5 deletions(-)

diff --git a/micrograd/jit.py b/micrograd/jit.py
index 408dd394..2f3b6c9b 100644
--- a/micrograd/jit.py
+++ b/micrograd/jit.py
@@ -9,7 +9,7 @@
 from mlir import ir
 from typing import Union, Optional
 import math
-from ctypes import c_float, byref
+from ctypes import c_float, byref, pointer
 
 
 class Compiler:
@@ -50,6 +50,13 @@ def _get_args_num(net: Union[Value, Neuron, Layer, MLP]) -> int:
     assert isinstance(net, Value)
     return 0
 
+def _get_results_num(net: Union[Value, Neuron, Layer, MLP]) -> int:
+    if isinstance(net, Layer):
+        return len(net.neurons)
+    if isinstance(net, MLP):
+        return _get_results_num(net.layers[-1])
+    assert isinstance(net, Value) or isinstance(net, Neuron)
+    return 1
 
 def _compile(net: Union[Value, Neuron, Layer, MLP]):
     args_num = _get_args_num(net)
@@ -102,10 +109,22 @@ def __call__(self, x: Optional[list[float]] = None):
         if isinstance(self.net, Value) and x != None:
             raise "You should not pass any arguments to a Value."
         xs = [] if isinstance(self.net, Value) else x
+
         args = [byref(c_float(v)) for v in xs]
-        res = c_float(-1.0)
-        self.execution_engine.invoke("main", *args, byref(res))
-        return res.value
+
+        num_results = _get_results_num(self.net)
+        FloatResultArrayType = (c_float * num_results)
+        res = FloatResultArrayType(-1)
+
+        # Why is this a double pointer?
+        # no clue...
+        if num_results == 1:
+            args = args + [byref(res)]
+        else:
+            args = [pointer(pointer(res))] + args
+
+        self.execution_engine.invoke("main", *args, res)
+        return res[0] if num_results == 1 else [res[i] for i in range(num_results)]
 
     def __str__(self):
         return str(self.m)
diff --git a/test/test_jit.py b/test/test_jit.py
index abb2c17d..61bf4dec 100644
--- a/test/test_jit.py
+++ b/test/test_jit.py
@@ -32,7 +32,15 @@ def test_layer():
     args = [-30., -20.]
     assert math.isclose(l(args).data, jl(args), abs_tol=1e-04)
 
-
+def test_layer_multiple_out():
+    random.seed(10)
+    l = Layer(nin=2, nout=2)
+    jl = jit(l)
+    print(jl)
+    args = [-30., -20.]
+    for r, jr in zip(l(args), jl(args)):
+        assert math.isclose(r.data, jr, abs_tol=1e-04)
+    
 def test_mlp():
     random.seed(10)
     nn = MLP(nin=2, nouts=[1])
@@ -47,3 +55,12 @@ def test_mlp_complex():
     jnn = jit(nn)
     args = [-30., -20.]
     assert math.isclose(nn(args).data, jnn(args), abs_tol=1e-04)
+
+def test_mlp_complex_multiple_out():
+    random.seed(10)
+    nn = MLP(nin=2, nouts=[2, 2])
+    jnn = jit(nn)
+    args = [-30., -20.]
+    for r, jr in zip(nn(args), jnn(args)):
+        assert math.isclose(r.data, jr, abs_tol=1e-04)
+    

From c64757b6cfc7414dc7bc3885d241250fc3a6430c Mon Sep 17 00:00:00 2001
From: Farid Zakaria <fmzakari@google.com>
Date: Fri, 1 Mar 2024 00:49:08 +0000
Subject: [PATCH 18/22] Remove extra argument to execution_engine

---
 micrograd/jit.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/micrograd/jit.py b/micrograd/jit.py
index 2f3b6c9b..0d046374 100644
--- a/micrograd/jit.py
+++ b/micrograd/jit.py
@@ -123,7 +123,7 @@ def __call__(self, x: Optional[list[float]] = None):
         else:
             args = [pointer(pointer(res))] + args
 
-        self.execution_engine.invoke("main", *args, res)
+        self.execution_engine.invoke("main", *args)
         return res[0] if num_results == 1 else [res[i] for i in range(num_results)]
 
     def __str__(self):

From 284c2f1bc4663d02c51acf70753a5aa901e884a2 Mon Sep 17 00:00:00 2001
From: Farid Zakaria <fmzakari@google.com>
Date: Fri, 1 Mar 2024 18:42:15 +0000
Subject: [PATCH 19/22] Add documentation

---
 micrograd/jit.py | 34 +++++++++++++++++++++++++++++++---
 1 file changed, 31 insertions(+), 3 deletions(-)

diff --git a/micrograd/jit.py b/micrograd/jit.py
index 0d046374..22d26372 100644
--- a/micrograd/jit.py
+++ b/micrograd/jit.py
@@ -1,3 +1,10 @@
+"""This is a small JIT compiler for micrograd computation graphs using MLIR.
+
+The MLIR is lowered to LLVM IR and then executed using an LLVM JIT engine.
+The comments in the file are meant to be liberal as this is a demonstration
+and learning project.
+"""
+
 from micrograd.engine import Value
 from micrograd.nn import Neuron, Layer, MLP
 import mlir.dialects.arith as arith
@@ -50,6 +57,7 @@ def _get_args_num(net: Union[Value, Neuron, Layer, MLP]) -> int:
     assert isinstance(net, Value)
     return 0
 
+
 def _get_results_num(net: Union[Value, Neuron, Layer, MLP]) -> int:
     if isinstance(net, Layer):
         return len(net.neurons)
@@ -58,14 +66,31 @@ def _get_results_num(net: Union[Value, Neuron, Layer, MLP]) -> int:
     assert isinstance(net, Value) or isinstance(net, Neuron)
     return 1
 
+
 def _compile(net: Union[Value, Neuron, Layer, MLP]):
+    """Adds the main method to a MLIR module.
+
+    This function assumes it is called within a context and insertion point.
+    """
     args_num = _get_args_num(net)
     args_types = [ir.F32Type.get()] * args_num
     args_values = [Value(0) for _ in range(args_num)]
 
     @func.func(*args_types)
     def main(*args):
+        # This is a bit of a hack to figure out the computation graph.
+        # Rather than model the various remaining types such as
+        # Neuron, Layer, and MLP, we instead execute the computation
+        # and since the result is a Value it encodes the whole graph.
+        # This is OK since the point of JIT is to speedup subsequent
+        # executions.
         net_value = net if isinstance(net, Value) else net(args_values)
+        # The computation graph earlier was created with seed values of Value(0).
+        # We now need to replace these with the actual arguments provided to the
+        # MLIR main function.
+        # We accomplish this by creating a mapping from the seed values to the
+        # compiled arguments (cv). The walk method will replace the seed values
+        # when traversing the graph wth the actual arguments
         compiled_values = {v: cv for v, cv in zip(args_values, args)}
         compiler = Compiler(compiled_values)
         if isinstance(net_value, list):
@@ -113,11 +138,14 @@ def __call__(self, x: Optional[list[float]] = None):
         args = [byref(c_float(v)) for v in xs]
 
         num_results = _get_results_num(self.net)
-        FloatResultArrayType = (c_float * num_results)
+        FloatResultArrayType = c_float * num_results
         res = FloatResultArrayType(-1)
 
-        # Why is this a double pointer?
-        # no clue...
+        # ExecutionEngine has odd semantics if an argument is a pointer.
+        # Some networks can return a single value, others a list.
+        # This also changes the type of MLIR that is lowered to LLVM such that the
+        # return value must be in argument to the function now.
+        # https://github.com/llvm/llvm-project/issues/83599
         if num_results == 1:
             args = args + [byref(res)]
         else:

From e79081bb81d22c2c71e19fafa1254a25da921c00 Mon Sep 17 00:00:00 2001
From: Farid Zakaria <fmzakari@google.com>
Date: Fri, 1 Mar 2024 19:04:17 +0000
Subject: [PATCH 20/22] Added a new cell to the demo

---
 demo.ipynb | 3411 ++++++++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 3323 insertions(+), 88 deletions(-)

diff --git a/demo.ipynb b/demo.ipynb
index b8c12531..b437fed4 100644
--- a/demo.ipynb
+++ b/demo.ipynb
@@ -9,7 +9,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -21,7 +21,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -31,7 +31,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -41,24 +41,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.collections.PathCollection at 0x10f636400>"
+       "<matplotlib.collections.PathCollection at 0x7f8664c70210>"
       ]
      },
-     "execution_count": 4,
+     "execution_count": 9,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
-       "<Figure size 360x360 with 1 Axes>"
+       "<Figure size 500x500 with 1 Axes>"
       ]
      },
      "metadata": {},
@@ -79,7 +79,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [
     {
@@ -100,7 +100,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
@@ -144,7 +144,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [
     {
@@ -154,103 +154,103 @@
       "step 0 loss 0.8958441028683222, accuracy 50.0%\n",
       "step 1 loss 1.7235905336972022, accuracy 81.0%\n",
       "step 2 loss 0.7429006313851131, accuracy 77.0%\n",
-      "step 3 loss 0.7705641260584198, accuracy 82.0%\n",
+      "step 3 loss 0.7705641260584201, accuracy 82.0%\n",
       "step 4 loss 0.3692793385976538, accuracy 84.0%\n",
-      "step 5 loss 0.313545481918522, accuracy 86.0%\n",
+      "step 5 loss 0.31354548191852194, accuracy 86.0%\n",
       "step 6 loss 0.2814234349772435, accuracy 89.0%\n",
       "step 7 loss 0.26888733313983904, accuracy 91.0%\n",
       "step 8 loss 0.2567147286057417, accuracy 91.0%\n",
       "step 9 loss 0.2704862551637922, accuracy 91.0%\n",
-      "step 10 loss 0.24507023853658053, accuracy 91.0%\n",
-      "step 11 loss 0.2509905529791503, accuracy 92.0%\n",
-      "step 12 loss 0.21560951851922952, accuracy 91.0%\n",
-      "step 13 loss 0.23090378446402726, accuracy 93.0%\n",
+      "step 10 loss 0.2450702385365804, accuracy 91.0%\n",
+      "step 11 loss 0.25099055297915035, accuracy 92.0%\n",
+      "step 12 loss 0.21560951851922946, accuracy 91.0%\n",
+      "step 13 loss 0.23090378446402732, accuracy 93.0%\n",
       "step 14 loss 0.20152151227899445, accuracy 92.0%\n",
-      "step 15 loss 0.22574506279282217, accuracy 93.0%\n",
+      "step 15 loss 0.22574506279282222, accuracy 93.0%\n",
       "step 16 loss 0.19447987596204114, accuracy 92.0%\n",
       "step 17 loss 0.21089496199246363, accuracy 93.0%\n",
-      "step 18 loss 0.159830773563036, accuracy 94.0%\n",
-      "step 19 loss 0.1845374874688392, accuracy 93.0%\n",
+      "step 18 loss 0.15983077356303604, accuracy 94.0%\n",
+      "step 19 loss 0.18453748746883922, accuracy 93.0%\n",
       "step 20 loss 0.18977522856087634, accuracy 91.0%\n",
-      "step 21 loss 0.19072704042579647, accuracy 93.0%\n",
+      "step 21 loss 0.19072704042579644, accuracy 93.0%\n",
       "step 22 loss 0.11733695088756485, accuracy 97.0%\n",
-      "step 23 loss 0.12173524408232454, accuracy 95.0%\n",
+      "step 23 loss 0.12173524408232458, accuracy 95.0%\n",
       "step 24 loss 0.1261571261277045, accuracy 95.0%\n",
-      "step 25 loss 0.16049097780801674, accuracy 95.0%\n",
-      "step 26 loss 0.18747197705245805, accuracy 92.0%\n",
+      "step 25 loss 0.1604909778080168, accuracy 95.0%\n",
+      "step 26 loss 0.187471977052458, accuracy 92.0%\n",
       "step 27 loss 0.16741837891059408, accuracy 95.0%\n",
-      "step 28 loss 0.09586583491455399, accuracy 97.0%\n",
-      "step 29 loss 0.0877878370742091, accuracy 96.0%\n",
-      "step 30 loss 0.11731297569011848, accuracy 95.0%\n",
-      "step 31 loss 0.09340146460619836, accuracy 97.0%\n",
-      "step 32 loss 0.12454454903103446, accuracy 95.0%\n",
-      "step 33 loss 0.07984002652777272, accuracy 97.0%\n",
-      "step 34 loss 0.07727519232921673, accuracy 97.0%\n",
-      "step 35 loss 0.07661250143094483, accuracy 98.0%\n",
-      "step 36 loss 0.10610492379198365, accuracy 96.0%\n",
-      "step 37 loss 0.09062808429265976, accuracy 99.0%\n",
-      "step 38 loss 0.10671887043036932, accuracy 95.0%\n",
-      "step 39 loss 0.05225659921975849, accuracy 98.0%\n",
+      "step 28 loss 0.09586583491455392, accuracy 97.0%\n",
+      "step 29 loss 0.08778783707420913, accuracy 96.0%\n",
+      "step 30 loss 0.11731297569011855, accuracy 95.0%\n",
+      "step 31 loss 0.09340146460619837, accuracy 97.0%\n",
+      "step 32 loss 0.12454454903103458, accuracy 95.0%\n",
+      "step 33 loss 0.07984002652777264, accuracy 97.0%\n",
+      "step 34 loss 0.07727519232921669, accuracy 97.0%\n",
+      "step 35 loss 0.07661250143094486, accuracy 98.0%\n",
+      "step 36 loss 0.10610492379198373, accuracy 96.0%\n",
+      "step 37 loss 0.0906280842926597, accuracy 99.0%\n",
+      "step 38 loss 0.10671887043036928, accuracy 95.0%\n",
+      "step 39 loss 0.05225659921975845, accuracy 98.0%\n",
       "step 40 loss 0.06016009895234464, accuracy 100.0%\n",
       "step 41 loss 0.08596724533333942, accuracy 96.0%\n",
-      "step 42 loss 0.051121079431796, accuracy 99.0%\n",
-      "step 43 loss 0.052401424016428284, accuracy 97.0%\n",
-      "step 44 loss 0.045306841790015734, accuracy 100.0%\n",
+      "step 42 loss 0.05112107943179597, accuracy 99.0%\n",
+      "step 43 loss 0.05240142401642826, accuracy 97.0%\n",
+      "step 44 loss 0.0453068417900158, accuracy 100.0%\n",
       "step 45 loss 0.07211073370655095, accuracy 97.0%\n",
-      "step 46 loss 0.03334238651310234, accuracy 99.0%\n",
-      "step 47 loss 0.03143222795751122, accuracy 100.0%\n",
+      "step 46 loss 0.0333423865131023, accuracy 99.0%\n",
+      "step 47 loss 0.03143222795751127, accuracy 100.0%\n",
       "step 48 loss 0.03658536747111507, accuracy 99.0%\n",
-      "step 49 loss 0.04829139382390309, accuracy 99.0%\n",
-      "step 50 loss 0.09875114765619622, accuracy 96.0%\n",
-      "step 51 loss 0.05449063965875453, accuracy 99.0%\n",
+      "step 49 loss 0.04829139382390312, accuracy 99.0%\n",
+      "step 50 loss 0.09875114765619633, accuracy 96.0%\n",
+      "step 51 loss 0.05449063965875443, accuracy 99.0%\n",
       "step 52 loss 0.03392679435708309, accuracy 100.0%\n",
-      "step 53 loss 0.05261517263568441, accuracy 97.0%\n",
-      "step 54 loss 0.03250295251424923, accuracy 99.0%\n",
-      "step 55 loss 0.02888327387207822, accuracy 100.0%\n",
-      "step 56 loss 0.04139151104027239, accuracy 98.0%\n",
-      "step 57 loss 0.018987407426128502, accuracy 100.0%\n",
-      "step 58 loss 0.0252383352388374, accuracy 100.0%\n",
-      "step 59 loss 0.02079656521341895, accuracy 100.0%\n",
-      "step 60 loss 0.0325971115781023, accuracy 99.0%\n",
-      "step 61 loss 0.017863351693480307, accuracy 100.0%\n",
-      "step 62 loss 0.023008717832211683, accuracy 100.0%\n",
-      "step 63 loss 0.022079325463581503, accuracy 100.0%\n",
-      "step 64 loss 0.029432917853529684, accuracy 99.0%\n",
-      "step 65 loss 0.01625151464409193, accuracy 100.0%\n",
-      "step 66 loss 0.02846853448326446, accuracy 99.0%\n",
-      "step 67 loss 0.013994365546208731, accuracy 100.0%\n",
-      "step 68 loss 0.015552344843651405, accuracy 100.0%\n",
-      "step 69 loss 0.0338911994616017, accuracy 99.0%\n",
-      "step 70 loss 0.014229870065926908, accuracy 100.0%\n",
-      "step 71 loss 0.013255281583285504, accuracy 100.0%\n",
-      "step 72 loss 0.012300277590022063, accuracy 100.0%\n",
+      "step 53 loss 0.0526151726356844, accuracy 97.0%\n",
+      "step 54 loss 0.03250295251424919, accuracy 99.0%\n",
+      "step 55 loss 0.02888327387207826, accuracy 100.0%\n",
+      "step 56 loss 0.0413915110402724, accuracy 98.0%\n",
+      "step 57 loss 0.0189874074261285, accuracy 100.0%\n",
+      "step 58 loss 0.02523833523883739, accuracy 100.0%\n",
+      "step 59 loss 0.020796565213418966, accuracy 100.0%\n",
+      "step 60 loss 0.03259711157810226, accuracy 99.0%\n",
+      "step 61 loss 0.017863351693480318, accuracy 100.0%\n",
+      "step 62 loss 0.023008717832211693, accuracy 100.0%\n",
+      "step 63 loss 0.022079325463581552, accuracy 100.0%\n",
+      "step 64 loss 0.029432917853529653, accuracy 99.0%\n",
+      "step 65 loss 0.01625151464409195, accuracy 100.0%\n",
+      "step 66 loss 0.02846853448326444, accuracy 99.0%\n",
+      "step 67 loss 0.013994365546208722, accuracy 100.0%\n",
+      "step 68 loss 0.015552344843651457, accuracy 100.0%\n",
+      "step 69 loss 0.03389119946160167, accuracy 99.0%\n",
+      "step 70 loss 0.014229870065926919, accuracy 100.0%\n",
+      "step 71 loss 0.013255281583285499, accuracy 100.0%\n",
+      "step 72 loss 0.012300277590022066, accuracy 100.0%\n",
       "step 73 loss 0.012676052498355976, accuracy 100.0%\n",
-      "step 74 loss 0.020593811955954763, accuracy 100.0%\n",
-      "step 75 loss 0.011845398205364453, accuracy 100.0%\n",
-      "step 76 loss 0.016012697472883086, accuracy 100.0%\n",
-      "step 77 loss 0.025458360239222128, accuracy 100.0%\n",
-      "step 78 loss 0.014382930289661911, accuracy 100.0%\n",
-      "step 79 loss 0.011698962425817985, accuracy 100.0%\n",
-      "step 80 loss 0.012318500800515763, accuracy 100.0%\n",
-      "step 81 loss 0.014121117031464233, accuracy 100.0%\n",
-      "step 82 loss 0.011664591962446225, accuracy 100.0%\n",
-      "step 83 loss 0.011589314549188726, accuracy 100.0%\n",
-      "step 84 loss 0.010990299347735226, accuracy 100.0%\n",
+      "step 74 loss 0.02059381195595477, accuracy 100.0%\n",
+      "step 75 loss 0.011845398205364429, accuracy 100.0%\n",
+      "step 76 loss 0.016012697472883114, accuracy 100.0%\n",
+      "step 77 loss 0.02545836023922212, accuracy 100.0%\n",
+      "step 78 loss 0.014382930289661894, accuracy 100.0%\n",
+      "step 79 loss 0.011698962425817978, accuracy 100.0%\n",
+      "step 80 loss 0.012318500800515808, accuracy 100.0%\n",
+      "step 81 loss 0.014121117031464217, accuracy 100.0%\n",
+      "step 82 loss 0.011664591962446206, accuracy 100.0%\n",
+      "step 83 loss 0.011589314549188743, accuracy 100.0%\n",
+      "step 84 loss 0.010990299347735228, accuracy 100.0%\n",
       "step 85 loss 0.01098922672069161, accuracy 100.0%\n",
       "step 86 loss 0.010988193757655071, accuracy 100.0%\n",
       "step 87 loss 0.010987200447388707, accuracy 100.0%\n",
       "step 88 loss 0.010986246779084925, accuracy 100.0%\n",
-      "step 89 loss 0.010985332742365272, accuracy 100.0%\n",
+      "step 89 loss 0.010985332742365276, accuracy 100.0%\n",
       "step 90 loss 0.010984458327280174, accuracy 100.0%\n",
       "step 91 loss 0.010983623524308862, accuracy 100.0%\n",
       "step 92 loss 0.010982828324359073, accuracy 100.0%\n",
-      "step 93 loss 0.010982072718767003, accuracy 100.0%\n",
-      "step 94 loss 0.010981356699297042, accuracy 100.0%\n",
-      "step 95 loss 0.010980680258141723, accuracy 100.0%\n",
+      "step 93 loss 0.010982072718767001, accuracy 100.0%\n",
+      "step 94 loss 0.010981356699297043, accuracy 100.0%\n",
+      "step 95 loss 0.010980680258141725, accuracy 100.0%\n",
       "step 96 loss 0.010980043387921506, accuracy 100.0%\n",
       "step 97 loss 0.010979446081684675, accuracy 100.0%\n",
       "step 98 loss 0.010978888332907229, accuracy 100.0%\n",
-      "step 99 loss 0.010978370135492717, accuracy 100.0%\n"
+      "step 99 loss 0.010978370135492719, accuracy 100.0%\n"
      ]
     }
    ],
@@ -276,7 +276,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 20,
    "metadata": {},
    "outputs": [
     {
@@ -285,15 +285,15 @@
        "(-1.548639298268643, 1.951360701731357)"
       ]
      },
-     "execution_count": 8,
+     "execution_count": 20,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
+       "<Figure size 640x480 with 1 Axes>"
       ]
      },
      "metadata": {},
@@ -323,10 +323,3245 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 33,
    "metadata": {},
-   "outputs": [],
-   "source": []
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "module {\n",
+      "  llvm.func @main(%arg0: f32, %arg1: f32) -> f32 attributes {llvm.emit_c_interface} {\n",
+      "    %0 = llvm.mlir.constant(-0.848623216 : f32) : f32\n",
+      "    %1 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2 = llvm.mlir.constant(0.233290762 : f32) : f32\n",
+      "    %3 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %4 = llvm.mlir.constant(-0.0821817442 : f32) : f32\n",
+      "    %5 = llvm.fmul %arg1, %4  : f32\n",
+      "    %6 = llvm.mlir.constant(-0.732010245 : f32) : f32\n",
+      "    %7 = llvm.mlir.constant(-0.354400456 : f32) : f32\n",
+      "    %8 = llvm.fmul %arg0, %7  : f32\n",
+      "    %9 = llvm.fadd %8, %6  : f32\n",
+      "    %10 = llvm.fadd %5, %9  : f32\n",
+      "    %11 = llvm.intr.maximum(%10, %3)  : (f32, f32) -> f32\n",
+      "    %12 = llvm.fmul %11, %2  : f32\n",
+      "    %13 = llvm.mlir.constant(0.280878574 : f32) : f32\n",
+      "    %14 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %15 = llvm.mlir.constant(-0.169446096 : f32) : f32\n",
+      "    %16 = llvm.mlir.constant(-0.215495735 : f32) : f32\n",
+      "    %17 = llvm.fmul %arg0, %16  : f32\n",
+      "    %18 = llvm.fadd %17, %15  : f32\n",
+      "    %19 = llvm.mlir.constant(0.985414206 : f32) : f32\n",
+      "    %20 = llvm.fmul %arg1, %19  : f32\n",
+      "    %21 = llvm.fadd %18, %20  : f32\n",
+      "    %22 = llvm.intr.maximum(%21, %14)  : (f32, f32) -> f32\n",
+      "    %23 = llvm.fmul %22, %13  : f32\n",
+      "    %24 = llvm.mlir.constant(1.14427829 : f32) : f32\n",
+      "    %25 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %26 = llvm.mlir.constant(0.315162152 : f32) : f32\n",
+      "    %27 = llvm.mlir.constant(0.600057721 : f32) : f32\n",
+      "    %28 = llvm.fmul %arg0, %27  : f32\n",
+      "    %29 = llvm.fadd %28, %26  : f32\n",
+      "    %30 = llvm.mlir.constant(-0.313983649 : f32) : f32\n",
+      "    %31 = llvm.fmul %arg1, %30  : f32\n",
+      "    %32 = llvm.fadd %29, %31  : f32\n",
+      "    %33 = llvm.intr.maximum(%32, %25)  : (f32, f32) -> f32\n",
+      "    %34 = llvm.fmul %33, %24  : f32\n",
+      "    %35 = llvm.mlir.constant(-0.0526023097 : f32) : f32\n",
+      "    %36 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %37 = llvm.mlir.constant(0.58700037 : f32) : f32\n",
+      "    %38 = llvm.fmul %arg1, %37  : f32\n",
+      "    %39 = llvm.mlir.constant(-0.0791633725 : f32) : f32\n",
+      "    %40 = llvm.fmul %arg0, %39  : f32\n",
+      "    %41 = llvm.mlir.constant(-0.478744268 : f32) : f32\n",
+      "    %42 = llvm.fadd %40, %41  : f32\n",
+      "    %43 = llvm.fadd %38, %42  : f32\n",
+      "    %44 = llvm.intr.maximum(%43, %36)  : (f32, f32) -> f32\n",
+      "    %45 = llvm.fmul %44, %35  : f32\n",
+      "    %46 = llvm.mlir.constant(-0.097408615 : f32) : f32\n",
+      "    %47 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %48 = llvm.mlir.constant(0.49928996 : f32) : f32\n",
+      "    %49 = llvm.fmul %arg1, %48  : f32\n",
+      "    %50 = llvm.mlir.constant(-0.283014119 : f32) : f32\n",
+      "    %51 = llvm.fmul %arg0, %50  : f32\n",
+      "    %52 = llvm.mlir.constant(0.0311395917 : f32) : f32\n",
+      "    %53 = llvm.fadd %51, %52  : f32\n",
+      "    %54 = llvm.fadd %49, %53  : f32\n",
+      "    %55 = llvm.intr.maximum(%54, %47)  : (f32, f32) -> f32\n",
+      "    %56 = llvm.fmul %55, %46  : f32\n",
+      "    %57 = llvm.mlir.constant(0.23978588 : f32) : f32\n",
+      "    %58 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %59 = llvm.mlir.constant(-0.57726413 : f32) : f32\n",
+      "    %60 = llvm.fmul %arg1, %59  : f32\n",
+      "    %61 = llvm.mlir.constant(0.598408341 : f32) : f32\n",
+      "    %62 = llvm.fmul %arg0, %61  : f32\n",
+      "    %63 = llvm.mlir.constant(-0.580251634 : f32) : f32\n",
+      "    %64 = llvm.fadd %62, %63  : f32\n",
+      "    %65 = llvm.fadd %60, %64  : f32\n",
+      "    %66 = llvm.intr.maximum(%65, %58)  : (f32, f32) -> f32\n",
+      "    %67 = llvm.fmul %66, %57  : f32\n",
+      "    %68 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %69 = llvm.mlir.constant(-0.771490633 : f32) : f32\n",
+      "    %70 = llvm.fmul %arg1, %69  : f32\n",
+      "    %71 = llvm.mlir.constant(0.114797138 : f32) : f32\n",
+      "    %72 = llvm.mlir.constant(-0.56365943 : f32) : f32\n",
+      "    %73 = llvm.fmul %arg0, %72  : f32\n",
+      "    %74 = llvm.fadd %73, %71  : f32\n",
+      "    %75 = llvm.fadd %70, %74  : f32\n",
+      "    %76 = llvm.intr.maximum(%75, %68)  : (f32, f32) -> f32\n",
+      "    %77 = llvm.mlir.constant(-0.91345936 : f32) : f32\n",
+      "    %78 = llvm.fmul %76, %77  : f32\n",
+      "    %79 = llvm.mlir.constant(-0.137711897 : f32) : f32\n",
+      "    %80 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %81 = llvm.mlir.constant(9.201580e-01 : f32) : f32\n",
+      "    %82 = llvm.fmul %arg0, %81  : f32\n",
+      "    %83 = llvm.mlir.constant(-0.444333524 : f32) : f32\n",
+      "    %84 = llvm.fadd %82, %83  : f32\n",
+      "    %85 = llvm.mlir.constant(0.859033763 : f32) : f32\n",
+      "    %86 = llvm.fmul %arg1, %85  : f32\n",
+      "    %87 = llvm.fadd %84, %86  : f32\n",
+      "    %88 = llvm.intr.maximum(%87, %80)  : (f32, f32) -> f32\n",
+      "    %89 = llvm.fmul %88, %79  : f32\n",
+      "    %90 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %91 = llvm.mlir.constant(-0.148220554 : f32) : f32\n",
+      "    %92 = llvm.mlir.constant(-0.266904861 : f32) : f32\n",
+      "    %93 = llvm.fmul %arg0, %92  : f32\n",
+      "    %94 = llvm.fadd %93, %91  : f32\n",
+      "    %95 = llvm.mlir.constant(0.591641366 : f32) : f32\n",
+      "    %96 = llvm.fmul %arg1, %95  : f32\n",
+      "    %97 = llvm.fadd %94, %96  : f32\n",
+      "    %98 = llvm.intr.maximum(%97, %90)  : (f32, f32) -> f32\n",
+      "    %99 = llvm.mlir.constant(0.395786822 : f32) : f32\n",
+      "    %100 = llvm.fmul %98, %99  : f32\n",
+      "    %101 = llvm.mlir.constant(-0.892391324 : f32) : f32\n",
+      "    %102 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %103 = llvm.mlir.constant(0.73282814 : f32) : f32\n",
+      "    %104 = llvm.fmul %arg1, %103  : f32\n",
+      "    %105 = llvm.mlir.constant(-0.632541954 : f32) : f32\n",
+      "    %106 = llvm.fmul %arg0, %105  : f32\n",
+      "    %107 = llvm.mlir.constant(-0.0431155674 : f32) : f32\n",
+      "    %108 = llvm.fadd %106, %107  : f32\n",
+      "    %109 = llvm.fadd %104, %108  : f32\n",
+      "    %110 = llvm.intr.maximum(%109, %102)  : (f32, f32) -> f32\n",
+      "    %111 = llvm.fmul %110, %101  : f32\n",
+      "    %112 = llvm.mlir.constant(-0.0317407139 : f32) : f32\n",
+      "    %113 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %114 = llvm.mlir.constant(0.250564575 : f32) : f32\n",
+      "    %115 = llvm.fmul %arg1, %114  : f32\n",
+      "    %116 = llvm.mlir.constant(-0.234713525 : f32) : f32\n",
+      "    %117 = llvm.mlir.constant(-0.0761275962 : f32) : f32\n",
+      "    %118 = llvm.fmul %arg0, %117  : f32\n",
+      "    %119 = llvm.fadd %118, %116  : f32\n",
+      "    %120 = llvm.fadd %115, %119  : f32\n",
+      "    %121 = llvm.intr.maximum(%120, %113)  : (f32, f32) -> f32\n",
+      "    %122 = llvm.mlir.constant(0.085449256 : f32) : f32\n",
+      "    %123 = llvm.fmul %121, %122  : f32\n",
+      "    %124 = llvm.fadd %123, %112  : f32\n",
+      "    %125 = llvm.mlir.constant(0.362902254 : f32) : f32\n",
+      "    %126 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %127 = llvm.mlir.constant(-0.710041642 : f32) : f32\n",
+      "    %128 = llvm.fmul %arg0, %127  : f32\n",
+      "    %129 = llvm.mlir.constant(-0.179663792 : f32) : f32\n",
+      "    %130 = llvm.fadd %128, %129  : f32\n",
+      "    %131 = llvm.mlir.constant(0.5115695 : f32) : f32\n",
+      "    %132 = llvm.fmul %arg1, %131  : f32\n",
+      "    %133 = llvm.fadd %130, %132  : f32\n",
+      "    %134 = llvm.intr.maximum(%133, %126)  : (f32, f32) -> f32\n",
+      "    %135 = llvm.fmul %134, %125  : f32\n",
+      "    %136 = llvm.fadd %124, %135  : f32\n",
+      "    %137 = llvm.fadd %111, %136  : f32\n",
+      "    %138 = llvm.fadd %100, %137  : f32\n",
+      "    %139 = llvm.mlir.constant(-0.372327119 : f32) : f32\n",
+      "    %140 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %141 = llvm.mlir.constant(-0.732560634 : f32) : f32\n",
+      "    %142 = llvm.mlir.constant(0.659632384 : f32) : f32\n",
+      "    %143 = llvm.fmul %arg0, %142  : f32\n",
+      "    %144 = llvm.fadd %143, %141  : f32\n",
+      "    %145 = llvm.mlir.constant(-0.124262765 : f32) : f32\n",
+      "    %146 = llvm.fmul %arg1, %145  : f32\n",
+      "    %147 = llvm.fadd %144, %146  : f32\n",
+      "    %148 = llvm.intr.maximum(%147, %140)  : (f32, f32) -> f32\n",
+      "    %149 = llvm.fmul %148, %139  : f32\n",
+      "    %150 = llvm.fadd %138, %149  : f32\n",
+      "    %151 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %152 = llvm.mlir.constant(-1.00863016 : f32) : f32\n",
+      "    %153 = llvm.fmul %arg1, %152  : f32\n",
+      "    %154 = llvm.mlir.constant(-1.543290e+00 : f32) : f32\n",
+      "    %155 = llvm.mlir.constant(1.41260469 : f32) : f32\n",
+      "    %156 = llvm.fmul %arg0, %155  : f32\n",
+      "    %157 = llvm.fadd %156, %154  : f32\n",
+      "    %158 = llvm.fadd %153, %157  : f32\n",
+      "    %159 = llvm.intr.maximum(%158, %151)  : (f32, f32) -> f32\n",
+      "    %160 = llvm.mlir.constant(-1.00866961 : f32) : f32\n",
+      "    %161 = llvm.fmul %159, %160  : f32\n",
+      "    %162 = llvm.fadd %150, %161  : f32\n",
+      "    %163 = llvm.fadd %89, %162  : f32\n",
+      "    %164 = llvm.mlir.constant(0.974710762 : f32) : f32\n",
+      "    %165 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %166 = llvm.mlir.constant(0.766540825 : f32) : f32\n",
+      "    %167 = llvm.fmul %arg1, %166  : f32\n",
+      "    %168 = llvm.mlir.constant(-0.924045622 : f32) : f32\n",
+      "    %169 = llvm.fmul %arg0, %168  : f32\n",
+      "    %170 = llvm.mlir.constant(-0.259199619 : f32) : f32\n",
+      "    %171 = llvm.fadd %169, %170  : f32\n",
+      "    %172 = llvm.fadd %167, %171  : f32\n",
+      "    %173 = llvm.intr.maximum(%172, %165)  : (f32, f32) -> f32\n",
+      "    %174 = llvm.fmul %173, %164  : f32\n",
+      "    %175 = llvm.fadd %163, %174  : f32\n",
+      "    %176 = llvm.fadd %78, %175  : f32\n",
+      "    %177 = llvm.fadd %67, %176  : f32\n",
+      "    %178 = llvm.fadd %56, %177  : f32\n",
+      "    %179 = llvm.fadd %45, %178  : f32\n",
+      "    %180 = llvm.fadd %34, %179  : f32\n",
+      "    %181 = llvm.fadd %23, %180  : f32\n",
+      "    %182 = llvm.fadd %12, %181  : f32\n",
+      "    %183 = llvm.mlir.constant(0.178221464 : f32) : f32\n",
+      "    %184 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %185 = llvm.mlir.constant(-0.217542693 : f32) : f32\n",
+      "    %186 = llvm.mlir.constant(0.876379132 : f32) : f32\n",
+      "    %187 = llvm.fmul %arg0, %186  : f32\n",
+      "    %188 = llvm.fadd %187, %185  : f32\n",
+      "    %189 = llvm.mlir.constant(0.950005471 : f32) : f32\n",
+      "    %190 = llvm.fmul %arg1, %189  : f32\n",
+      "    %191 = llvm.fadd %188, %190  : f32\n",
+      "    %192 = llvm.intr.maximum(%191, %184)  : (f32, f32) -> f32\n",
+      "    %193 = llvm.fmul %192, %183  : f32\n",
+      "    %194 = llvm.fadd %182, %193  : f32\n",
+      "    %195 = llvm.intr.maximum(%194, %1)  : (f32, f32) -> f32\n",
+      "    %196 = llvm.fmul %195, %0  : f32\n",
+      "    %197 = llvm.mlir.constant(0.160405979 : f32) : f32\n",
+      "    %198 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %199 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %200 = llvm.mlir.constant(-0.217542693 : f32) : f32\n",
+      "    %201 = llvm.mlir.constant(0.876379132 : f32) : f32\n",
+      "    %202 = llvm.fmul %arg0, %201  : f32\n",
+      "    %203 = llvm.fadd %202, %200  : f32\n",
+      "    %204 = llvm.mlir.constant(0.950005471 : f32) : f32\n",
+      "    %205 = llvm.fmul %arg1, %204  : f32\n",
+      "    %206 = llvm.fadd %203, %205  : f32\n",
+      "    %207 = llvm.intr.maximum(%206, %199)  : (f32, f32) -> f32\n",
+      "    %208 = llvm.mlir.constant(-0.815683365 : f32) : f32\n",
+      "    %209 = llvm.fmul %207, %208  : f32\n",
+      "    %210 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %211 = llvm.mlir.constant(0.49928996 : f32) : f32\n",
+      "    %212 = llvm.fmul %arg1, %211  : f32\n",
+      "    %213 = llvm.mlir.constant(-0.283014119 : f32) : f32\n",
+      "    %214 = llvm.fmul %arg0, %213  : f32\n",
+      "    %215 = llvm.mlir.constant(0.0311395917 : f32) : f32\n",
+      "    %216 = llvm.fadd %214, %215  : f32\n",
+      "    %217 = llvm.fadd %212, %216  : f32\n",
+      "    %218 = llvm.intr.maximum(%217, %210)  : (f32, f32) -> f32\n",
+      "    %219 = llvm.mlir.constant(-0.348928839 : f32) : f32\n",
+      "    %220 = llvm.fmul %218, %219  : f32\n",
+      "    %221 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %222 = llvm.mlir.constant(-0.57726413 : f32) : f32\n",
+      "    %223 = llvm.fmul %arg1, %222  : f32\n",
+      "    %224 = llvm.mlir.constant(0.598408341 : f32) : f32\n",
+      "    %225 = llvm.fmul %arg0, %224  : f32\n",
+      "    %226 = llvm.mlir.constant(-0.580251634 : f32) : f32\n",
+      "    %227 = llvm.fadd %225, %226  : f32\n",
+      "    %228 = llvm.fadd %223, %227  : f32\n",
+      "    %229 = llvm.intr.maximum(%228, %221)  : (f32, f32) -> f32\n",
+      "    %230 = llvm.mlir.constant(0.587140262 : f32) : f32\n",
+      "    %231 = llvm.fmul %229, %230  : f32\n",
+      "    %232 = llvm.mlir.constant(0.390852392 : f32) : f32\n",
+      "    %233 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %234 = llvm.mlir.constant(0.766540825 : f32) : f32\n",
+      "    %235 = llvm.fmul %arg1, %234  : f32\n",
+      "    %236 = llvm.mlir.constant(-0.924045622 : f32) : f32\n",
+      "    %237 = llvm.fmul %arg0, %236  : f32\n",
+      "    %238 = llvm.mlir.constant(-0.259199619 : f32) : f32\n",
+      "    %239 = llvm.fadd %237, %238  : f32\n",
+      "    %240 = llvm.fadd %235, %239  : f32\n",
+      "    %241 = llvm.intr.maximum(%240, %233)  : (f32, f32) -> f32\n",
+      "    %242 = llvm.fmul %241, %232  : f32\n",
+      "    %243 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %244 = llvm.mlir.constant(0.250564575 : f32) : f32\n",
+      "    %245 = llvm.fmul %arg1, %244  : f32\n",
+      "    %246 = llvm.mlir.constant(-0.234713525 : f32) : f32\n",
+      "    %247 = llvm.mlir.constant(-0.0761275962 : f32) : f32\n",
+      "    %248 = llvm.fmul %arg0, %247  : f32\n",
+      "    %249 = llvm.fadd %248, %246  : f32\n",
+      "    %250 = llvm.fadd %245, %249  : f32\n",
+      "    %251 = llvm.intr.maximum(%250, %243)  : (f32, f32) -> f32\n",
+      "    %252 = llvm.mlir.constant(0.879071354 : f32) : f32\n",
+      "    %253 = llvm.fmul %251, %252  : f32\n",
+      "    %254 = llvm.mlir.constant(-0.134109154 : f32) : f32\n",
+      "    %255 = llvm.fadd %253, %254  : f32\n",
+      "    %256 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %257 = llvm.mlir.constant(-0.710041642 : f32) : f32\n",
+      "    %258 = llvm.fmul %arg0, %257  : f32\n",
+      "    %259 = llvm.mlir.constant(-0.179663792 : f32) : f32\n",
+      "    %260 = llvm.fadd %258, %259  : f32\n",
+      "    %261 = llvm.mlir.constant(0.5115695 : f32) : f32\n",
+      "    %262 = llvm.fmul %arg1, %261  : f32\n",
+      "    %263 = llvm.fadd %260, %262  : f32\n",
+      "    %264 = llvm.intr.maximum(%263, %256)  : (f32, f32) -> f32\n",
+      "    %265 = llvm.mlir.constant(0.0331596658 : f32) : f32\n",
+      "    %266 = llvm.fmul %264, %265  : f32\n",
+      "    %267 = llvm.fadd %255, %266  : f32\n",
+      "    %268 = llvm.mlir.constant(0.484665155 : f32) : f32\n",
+      "    %269 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %270 = llvm.mlir.constant(0.73282814 : f32) : f32\n",
+      "    %271 = llvm.fmul %arg1, %270  : f32\n",
+      "    %272 = llvm.mlir.constant(-0.632541954 : f32) : f32\n",
+      "    %273 = llvm.fmul %arg0, %272  : f32\n",
+      "    %274 = llvm.mlir.constant(-0.0431155674 : f32) : f32\n",
+      "    %275 = llvm.fadd %273, %274  : f32\n",
+      "    %276 = llvm.fadd %271, %275  : f32\n",
+      "    %277 = llvm.intr.maximum(%276, %269)  : (f32, f32) -> f32\n",
+      "    %278 = llvm.fmul %277, %268  : f32\n",
+      "    %279 = llvm.fadd %267, %278  : f32\n",
+      "    %280 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %281 = llvm.mlir.constant(-0.148220554 : f32) : f32\n",
+      "    %282 = llvm.mlir.constant(-0.266904861 : f32) : f32\n",
+      "    %283 = llvm.fmul %arg0, %282  : f32\n",
+      "    %284 = llvm.fadd %283, %281  : f32\n",
+      "    %285 = llvm.mlir.constant(0.591641366 : f32) : f32\n",
+      "    %286 = llvm.fmul %arg1, %285  : f32\n",
+      "    %287 = llvm.fadd %284, %286  : f32\n",
+      "    %288 = llvm.intr.maximum(%287, %280)  : (f32, f32) -> f32\n",
+      "    %289 = llvm.mlir.constant(-0.789754033 : f32) : f32\n",
+      "    %290 = llvm.fmul %288, %289  : f32\n",
+      "    %291 = llvm.fadd %279, %290  : f32\n",
+      "    %292 = llvm.mlir.constant(0.713330686 : f32) : f32\n",
+      "    %293 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %294 = llvm.mlir.constant(-0.732560634 : f32) : f32\n",
+      "    %295 = llvm.mlir.constant(0.659632384 : f32) : f32\n",
+      "    %296 = llvm.fmul %arg0, %295  : f32\n",
+      "    %297 = llvm.fadd %296, %294  : f32\n",
+      "    %298 = llvm.mlir.constant(-0.124262765 : f32) : f32\n",
+      "    %299 = llvm.fmul %arg1, %298  : f32\n",
+      "    %300 = llvm.fadd %297, %299  : f32\n",
+      "    %301 = llvm.intr.maximum(%300, %293)  : (f32, f32) -> f32\n",
+      "    %302 = llvm.fmul %301, %292  : f32\n",
+      "    %303 = llvm.fadd %291, %302  : f32\n",
+      "    %304 = llvm.mlir.constant(-0.503773749 : f32) : f32\n",
+      "    %305 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %306 = llvm.mlir.constant(-1.00863016 : f32) : f32\n",
+      "    %307 = llvm.fmul %arg1, %306  : f32\n",
+      "    %308 = llvm.mlir.constant(-1.543290e+00 : f32) : f32\n",
+      "    %309 = llvm.mlir.constant(1.41260469 : f32) : f32\n",
+      "    %310 = llvm.fmul %arg0, %309  : f32\n",
+      "    %311 = llvm.fadd %310, %308  : f32\n",
+      "    %312 = llvm.fadd %307, %311  : f32\n",
+      "    %313 = llvm.intr.maximum(%312, %305)  : (f32, f32) -> f32\n",
+      "    %314 = llvm.fmul %313, %304  : f32\n",
+      "    %315 = llvm.fadd %303, %314  : f32\n",
+      "    %316 = llvm.mlir.constant(-9.108960e-01 : f32) : f32\n",
+      "    %317 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %318 = llvm.mlir.constant(9.201580e-01 : f32) : f32\n",
+      "    %319 = llvm.fmul %arg0, %318  : f32\n",
+      "    %320 = llvm.mlir.constant(-0.444333524 : f32) : f32\n",
+      "    %321 = llvm.fadd %319, %320  : f32\n",
+      "    %322 = llvm.mlir.constant(0.859033763 : f32) : f32\n",
+      "    %323 = llvm.fmul %arg1, %322  : f32\n",
+      "    %324 = llvm.fadd %321, %323  : f32\n",
+      "    %325 = llvm.intr.maximum(%324, %317)  : (f32, f32) -> f32\n",
+      "    %326 = llvm.fmul %325, %316  : f32\n",
+      "    %327 = llvm.fadd %315, %326  : f32\n",
+      "    %328 = llvm.fadd %242, %327  : f32\n",
+      "    %329 = llvm.mlir.constant(-0.0370214842 : f32) : f32\n",
+      "    %330 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %331 = llvm.mlir.constant(-0.771490633 : f32) : f32\n",
+      "    %332 = llvm.fmul %arg1, %331  : f32\n",
+      "    %333 = llvm.mlir.constant(0.114797138 : f32) : f32\n",
+      "    %334 = llvm.mlir.constant(-0.56365943 : f32) : f32\n",
+      "    %335 = llvm.fmul %arg0, %334  : f32\n",
+      "    %336 = llvm.fadd %335, %333  : f32\n",
+      "    %337 = llvm.fadd %332, %336  : f32\n",
+      "    %338 = llvm.intr.maximum(%337, %330)  : (f32, f32) -> f32\n",
+      "    %339 = llvm.fmul %338, %329  : f32\n",
+      "    %340 = llvm.fadd %328, %339  : f32\n",
+      "    %341 = llvm.fadd %231, %340  : f32\n",
+      "    %342 = llvm.fadd %220, %341  : f32\n",
+      "    %343 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %344 = llvm.mlir.constant(0.58700037 : f32) : f32\n",
+      "    %345 = llvm.fmul %arg1, %344  : f32\n",
+      "    %346 = llvm.mlir.constant(-0.0791633725 : f32) : f32\n",
+      "    %347 = llvm.fmul %arg0, %346  : f32\n",
+      "    %348 = llvm.mlir.constant(-0.478744268 : f32) : f32\n",
+      "    %349 = llvm.fadd %347, %348  : f32\n",
+      "    %350 = llvm.fadd %345, %349  : f32\n",
+      "    %351 = llvm.intr.maximum(%350, %343)  : (f32, f32) -> f32\n",
+      "    %352 = llvm.mlir.constant(0.47513634 : f32) : f32\n",
+      "    %353 = llvm.fmul %351, %352  : f32\n",
+      "    %354 = llvm.fadd %342, %353  : f32\n",
+      "    %355 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %356 = llvm.mlir.constant(0.315162152 : f32) : f32\n",
+      "    %357 = llvm.mlir.constant(0.600057721 : f32) : f32\n",
+      "    %358 = llvm.fmul %arg0, %357  : f32\n",
+      "    %359 = llvm.fadd %358, %356  : f32\n",
+      "    %360 = llvm.mlir.constant(-0.313983649 : f32) : f32\n",
+      "    %361 = llvm.fmul %arg1, %360  : f32\n",
+      "    %362 = llvm.fadd %359, %361  : f32\n",
+      "    %363 = llvm.intr.maximum(%362, %355)  : (f32, f32) -> f32\n",
+      "    %364 = llvm.mlir.constant(0.0867761225 : f32) : f32\n",
+      "    %365 = llvm.fmul %363, %364  : f32\n",
+      "    %366 = llvm.fadd %354, %365  : f32\n",
+      "    %367 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %368 = llvm.mlir.constant(-0.169446096 : f32) : f32\n",
+      "    %369 = llvm.mlir.constant(-0.215495735 : f32) : f32\n",
+      "    %370 = llvm.fmul %arg0, %369  : f32\n",
+      "    %371 = llvm.fadd %370, %368  : f32\n",
+      "    %372 = llvm.mlir.constant(0.985414206 : f32) : f32\n",
+      "    %373 = llvm.fmul %arg1, %372  : f32\n",
+      "    %374 = llvm.fadd %371, %373  : f32\n",
+      "    %375 = llvm.intr.maximum(%374, %367)  : (f32, f32) -> f32\n",
+      "    %376 = llvm.mlir.constant(-0.343674332 : f32) : f32\n",
+      "    %377 = llvm.fmul %375, %376  : f32\n",
+      "    %378 = llvm.fadd %366, %377  : f32\n",
+      "    %379 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %380 = llvm.mlir.constant(-0.0821817442 : f32) : f32\n",
+      "    %381 = llvm.fmul %arg1, %380  : f32\n",
+      "    %382 = llvm.mlir.constant(-0.732010245 : f32) : f32\n",
+      "    %383 = llvm.mlir.constant(-0.354400456 : f32) : f32\n",
+      "    %384 = llvm.fmul %arg0, %383  : f32\n",
+      "    %385 = llvm.fadd %384, %382  : f32\n",
+      "    %386 = llvm.fadd %381, %385  : f32\n",
+      "    %387 = llvm.intr.maximum(%386, %379)  : (f32, f32) -> f32\n",
+      "    %388 = llvm.mlir.constant(0.301632375 : f32) : f32\n",
+      "    %389 = llvm.fmul %387, %388  : f32\n",
+      "    %390 = llvm.fadd %378, %389  : f32\n",
+      "    %391 = llvm.fadd %209, %390  : f32\n",
+      "    %392 = llvm.intr.maximum(%391, %198)  : (f32, f32) -> f32\n",
+      "    %393 = llvm.fmul %392, %197  : f32\n",
+      "    %394 = llvm.mlir.constant(-0.275410712 : f32) : f32\n",
+      "    %395 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %396 = llvm.mlir.constant(-0.948784649 : f32) : f32\n",
+      "    %397 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %398 = llvm.mlir.constant(-0.217542693 : f32) : f32\n",
+      "    %399 = llvm.mlir.constant(0.876379132 : f32) : f32\n",
+      "    %400 = llvm.fmul %arg0, %399  : f32\n",
+      "    %401 = llvm.fadd %400, %398  : f32\n",
+      "    %402 = llvm.mlir.constant(0.950005471 : f32) : f32\n",
+      "    %403 = llvm.fmul %arg1, %402  : f32\n",
+      "    %404 = llvm.fadd %401, %403  : f32\n",
+      "    %405 = llvm.intr.maximum(%404, %397)  : (f32, f32) -> f32\n",
+      "    %406 = llvm.fmul %405, %396  : f32\n",
+      "    %407 = llvm.mlir.constant(-0.831044436 : f32) : f32\n",
+      "    %408 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %409 = llvm.mlir.constant(0.315162152 : f32) : f32\n",
+      "    %410 = llvm.mlir.constant(0.600057721 : f32) : f32\n",
+      "    %411 = llvm.fmul %arg0, %410  : f32\n",
+      "    %412 = llvm.fadd %411, %409  : f32\n",
+      "    %413 = llvm.mlir.constant(-0.313983649 : f32) : f32\n",
+      "    %414 = llvm.fmul %arg1, %413  : f32\n",
+      "    %415 = llvm.fadd %412, %414  : f32\n",
+      "    %416 = llvm.intr.maximum(%415, %408)  : (f32, f32) -> f32\n",
+      "    %417 = llvm.fmul %416, %407  : f32\n",
+      "    %418 = llvm.mlir.constant(0.203657344 : f32) : f32\n",
+      "    %419 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %420 = llvm.mlir.constant(0.58700037 : f32) : f32\n",
+      "    %421 = llvm.fmul %arg1, %420  : f32\n",
+      "    %422 = llvm.mlir.constant(-0.0791633725 : f32) : f32\n",
+      "    %423 = llvm.fmul %arg0, %422  : f32\n",
+      "    %424 = llvm.mlir.constant(-0.478744268 : f32) : f32\n",
+      "    %425 = llvm.fadd %423, %424  : f32\n",
+      "    %426 = llvm.fadd %421, %425  : f32\n",
+      "    %427 = llvm.intr.maximum(%426, %419)  : (f32, f32) -> f32\n",
+      "    %428 = llvm.fmul %427, %418  : f32\n",
+      "    %429 = llvm.mlir.constant(-0.543747842 : f32) : f32\n",
+      "    %430 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %431 = llvm.mlir.constant(0.49928996 : f32) : f32\n",
+      "    %432 = llvm.fmul %arg1, %431  : f32\n",
+      "    %433 = llvm.mlir.constant(-0.283014119 : f32) : f32\n",
+      "    %434 = llvm.fmul %arg0, %433  : f32\n",
+      "    %435 = llvm.mlir.constant(0.0311395917 : f32) : f32\n",
+      "    %436 = llvm.fadd %434, %435  : f32\n",
+      "    %437 = llvm.fadd %432, %436  : f32\n",
+      "    %438 = llvm.intr.maximum(%437, %430)  : (f32, f32) -> f32\n",
+      "    %439 = llvm.fmul %438, %429  : f32\n",
+      "    %440 = llvm.mlir.constant(0.922435641 : f32) : f32\n",
+      "    %441 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %442 = llvm.mlir.constant(9.201580e-01 : f32) : f32\n",
+      "    %443 = llvm.fmul %arg0, %442  : f32\n",
+      "    %444 = llvm.mlir.constant(-0.444333524 : f32) : f32\n",
+      "    %445 = llvm.fadd %443, %444  : f32\n",
+      "    %446 = llvm.mlir.constant(0.859033763 : f32) : f32\n",
+      "    %447 = llvm.fmul %arg1, %446  : f32\n",
+      "    %448 = llvm.fadd %445, %447  : f32\n",
+      "    %449 = llvm.intr.maximum(%448, %441)  : (f32, f32) -> f32\n",
+      "    %450 = llvm.fmul %449, %440  : f32\n",
+      "    %451 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %452 = llvm.mlir.constant(-1.00863016 : f32) : f32\n",
+      "    %453 = llvm.fmul %arg1, %452  : f32\n",
+      "    %454 = llvm.mlir.constant(-1.543290e+00 : f32) : f32\n",
+      "    %455 = llvm.mlir.constant(1.41260469 : f32) : f32\n",
+      "    %456 = llvm.fmul %arg0, %455  : f32\n",
+      "    %457 = llvm.fadd %456, %454  : f32\n",
+      "    %458 = llvm.fadd %453, %457  : f32\n",
+      "    %459 = llvm.intr.maximum(%458, %451)  : (f32, f32) -> f32\n",
+      "    %460 = llvm.mlir.constant(-6.149900e-01 : f32) : f32\n",
+      "    %461 = llvm.fmul %459, %460  : f32\n",
+      "    %462 = llvm.mlir.constant(-0.84363234 : f32) : f32\n",
+      "    %463 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %464 = llvm.mlir.constant(-0.732560634 : f32) : f32\n",
+      "    %465 = llvm.mlir.constant(0.659632384 : f32) : f32\n",
+      "    %466 = llvm.fmul %arg0, %465  : f32\n",
+      "    %467 = llvm.fadd %466, %464  : f32\n",
+      "    %468 = llvm.mlir.constant(-0.124262765 : f32) : f32\n",
+      "    %469 = llvm.fmul %arg1, %468  : f32\n",
+      "    %470 = llvm.fadd %467, %469  : f32\n",
+      "    %471 = llvm.intr.maximum(%470, %463)  : (f32, f32) -> f32\n",
+      "    %472 = llvm.fmul %471, %462  : f32\n",
+      "    %473 = llvm.mlir.constant(0.00944971665 : f32) : f32\n",
+      "    %474 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %475 = llvm.mlir.constant(-0.710041642 : f32) : f32\n",
+      "    %476 = llvm.fmul %arg0, %475  : f32\n",
+      "    %477 = llvm.mlir.constant(-0.179663792 : f32) : f32\n",
+      "    %478 = llvm.fadd %476, %477  : f32\n",
+      "    %479 = llvm.mlir.constant(0.5115695 : f32) : f32\n",
+      "    %480 = llvm.fmul %arg1, %479  : f32\n",
+      "    %481 = llvm.fadd %478, %480  : f32\n",
+      "    %482 = llvm.intr.maximum(%481, %474)  : (f32, f32) -> f32\n",
+      "    %483 = llvm.fmul %482, %473  : f32\n",
+      "    %484 = llvm.mlir.constant(0.0309070516 : f32) : f32\n",
+      "    %485 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %486 = llvm.mlir.constant(0.250564575 : f32) : f32\n",
+      "    %487 = llvm.fmul %arg1, %486  : f32\n",
+      "    %488 = llvm.mlir.constant(-0.234713525 : f32) : f32\n",
+      "    %489 = llvm.mlir.constant(-0.0761275962 : f32) : f32\n",
+      "    %490 = llvm.fmul %arg0, %489  : f32\n",
+      "    %491 = llvm.fadd %490, %488  : f32\n",
+      "    %492 = llvm.fadd %487, %491  : f32\n",
+      "    %493 = llvm.intr.maximum(%492, %485)  : (f32, f32) -> f32\n",
+      "    %494 = llvm.mlir.constant(-0.645345569 : f32) : f32\n",
+      "    %495 = llvm.fmul %493, %494  : f32\n",
+      "    %496 = llvm.fadd %495, %484  : f32\n",
+      "    %497 = llvm.fadd %483, %496  : f32\n",
+      "    %498 = llvm.mlir.constant(0.372668415 : f32) : f32\n",
+      "    %499 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %500 = llvm.mlir.constant(0.73282814 : f32) : f32\n",
+      "    %501 = llvm.fmul %arg1, %500  : f32\n",
+      "    %502 = llvm.mlir.constant(-0.632541954 : f32) : f32\n",
+      "    %503 = llvm.fmul %arg0, %502  : f32\n",
+      "    %504 = llvm.mlir.constant(-0.0431155674 : f32) : f32\n",
+      "    %505 = llvm.fadd %503, %504  : f32\n",
+      "    %506 = llvm.fadd %501, %505  : f32\n",
+      "    %507 = llvm.intr.maximum(%506, %499)  : (f32, f32) -> f32\n",
+      "    %508 = llvm.fmul %507, %498  : f32\n",
+      "    %509 = llvm.fadd %497, %508  : f32\n",
+      "    %510 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %511 = llvm.mlir.constant(-0.148220554 : f32) : f32\n",
+      "    %512 = llvm.mlir.constant(-0.266904861 : f32) : f32\n",
+      "    %513 = llvm.fmul %arg0, %512  : f32\n",
+      "    %514 = llvm.fadd %513, %511  : f32\n",
+      "    %515 = llvm.mlir.constant(0.591641366 : f32) : f32\n",
+      "    %516 = llvm.fmul %arg1, %515  : f32\n",
+      "    %517 = llvm.fadd %514, %516  : f32\n",
+      "    %518 = llvm.intr.maximum(%517, %510)  : (f32, f32) -> f32\n",
+      "    %519 = llvm.mlir.constant(-0.616386771 : f32) : f32\n",
+      "    %520 = llvm.fmul %518, %519  : f32\n",
+      "    %521 = llvm.fadd %509, %520  : f32\n",
+      "    %522 = llvm.fadd %472, %521  : f32\n",
+      "    %523 = llvm.fadd %461, %522  : f32\n",
+      "    %524 = llvm.fadd %450, %523  : f32\n",
+      "    %525 = llvm.mlir.constant(0.306773573 : f32) : f32\n",
+      "    %526 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %527 = llvm.mlir.constant(0.766540825 : f32) : f32\n",
+      "    %528 = llvm.fmul %arg1, %527  : f32\n",
+      "    %529 = llvm.mlir.constant(-0.924045622 : f32) : f32\n",
+      "    %530 = llvm.fmul %arg0, %529  : f32\n",
+      "    %531 = llvm.mlir.constant(-0.259199619 : f32) : f32\n",
+      "    %532 = llvm.fadd %530, %531  : f32\n",
+      "    %533 = llvm.fadd %528, %532  : f32\n",
+      "    %534 = llvm.intr.maximum(%533, %526)  : (f32, f32) -> f32\n",
+      "    %535 = llvm.fmul %534, %525  : f32\n",
+      "    %536 = llvm.fadd %524, %535  : f32\n",
+      "    %537 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %538 = llvm.mlir.constant(-0.771490633 : f32) : f32\n",
+      "    %539 = llvm.fmul %arg1, %538  : f32\n",
+      "    %540 = llvm.mlir.constant(0.114797138 : f32) : f32\n",
+      "    %541 = llvm.mlir.constant(-0.56365943 : f32) : f32\n",
+      "    %542 = llvm.fmul %arg0, %541  : f32\n",
+      "    %543 = llvm.fadd %542, %540  : f32\n",
+      "    %544 = llvm.fadd %539, %543  : f32\n",
+      "    %545 = llvm.intr.maximum(%544, %537)  : (f32, f32) -> f32\n",
+      "    %546 = llvm.mlir.constant(5.738330e-01 : f32) : f32\n",
+      "    %547 = llvm.fmul %545, %546  : f32\n",
+      "    %548 = llvm.fadd %536, %547  : f32\n",
+      "    %549 = llvm.mlir.constant(-0.676522672 : f32) : f32\n",
+      "    %550 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %551 = llvm.mlir.constant(-0.57726413 : f32) : f32\n",
+      "    %552 = llvm.fmul %arg1, %551  : f32\n",
+      "    %553 = llvm.mlir.constant(0.598408341 : f32) : f32\n",
+      "    %554 = llvm.fmul %arg0, %553  : f32\n",
+      "    %555 = llvm.mlir.constant(-0.580251634 : f32) : f32\n",
+      "    %556 = llvm.fadd %554, %555  : f32\n",
+      "    %557 = llvm.fadd %552, %556  : f32\n",
+      "    %558 = llvm.intr.maximum(%557, %550)  : (f32, f32) -> f32\n",
+      "    %559 = llvm.fmul %558, %549  : f32\n",
+      "    %560 = llvm.fadd %548, %559  : f32\n",
+      "    %561 = llvm.fadd %439, %560  : f32\n",
+      "    %562 = llvm.fadd %428, %561  : f32\n",
+      "    %563 = llvm.fadd %417, %562  : f32\n",
+      "    %564 = llvm.mlir.constant(-0.538033664 : f32) : f32\n",
+      "    %565 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %566 = llvm.mlir.constant(-0.169446096 : f32) : f32\n",
+      "    %567 = llvm.mlir.constant(-0.215495735 : f32) : f32\n",
+      "    %568 = llvm.fmul %arg0, %567  : f32\n",
+      "    %569 = llvm.fadd %568, %566  : f32\n",
+      "    %570 = llvm.mlir.constant(0.985414206 : f32) : f32\n",
+      "    %571 = llvm.fmul %arg1, %570  : f32\n",
+      "    %572 = llvm.fadd %569, %571  : f32\n",
+      "    %573 = llvm.intr.maximum(%572, %565)  : (f32, f32) -> f32\n",
+      "    %574 = llvm.fmul %573, %564  : f32\n",
+      "    %575 = llvm.fadd %563, %574  : f32\n",
+      "    %576 = llvm.mlir.constant(-0.620972931 : f32) : f32\n",
+      "    %577 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %578 = llvm.mlir.constant(-0.0821817442 : f32) : f32\n",
+      "    %579 = llvm.fmul %arg1, %578  : f32\n",
+      "    %580 = llvm.mlir.constant(-0.732010245 : f32) : f32\n",
+      "    %581 = llvm.mlir.constant(-0.354400456 : f32) : f32\n",
+      "    %582 = llvm.fmul %arg0, %581  : f32\n",
+      "    %583 = llvm.fadd %582, %580  : f32\n",
+      "    %584 = llvm.fadd %579, %583  : f32\n",
+      "    %585 = llvm.intr.maximum(%584, %577)  : (f32, f32) -> f32\n",
+      "    %586 = llvm.fmul %585, %576  : f32\n",
+      "    %587 = llvm.fadd %575, %586  : f32\n",
+      "    %588 = llvm.fadd %406, %587  : f32\n",
+      "    %589 = llvm.intr.maximum(%588, %395)  : (f32, f32) -> f32\n",
+      "    %590 = llvm.fmul %589, %394  : f32\n",
+      "    %591 = llvm.mlir.constant(0.473938018 : f32) : f32\n",
+      "    %592 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %593 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %594 = llvm.mlir.constant(-0.217542693 : f32) : f32\n",
+      "    %595 = llvm.mlir.constant(0.876379132 : f32) : f32\n",
+      "    %596 = llvm.fmul %arg0, %595  : f32\n",
+      "    %597 = llvm.fadd %596, %594  : f32\n",
+      "    %598 = llvm.mlir.constant(0.950005471 : f32) : f32\n",
+      "    %599 = llvm.fmul %arg1, %598  : f32\n",
+      "    %600 = llvm.fadd %597, %599  : f32\n",
+      "    %601 = llvm.intr.maximum(%600, %593)  : (f32, f32) -> f32\n",
+      "    %602 = llvm.mlir.constant(-0.454258919 : f32) : f32\n",
+      "    %603 = llvm.fmul %601, %602  : f32\n",
+      "    %604 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %605 = llvm.mlir.constant(-0.169446096 : f32) : f32\n",
+      "    %606 = llvm.mlir.constant(-0.215495735 : f32) : f32\n",
+      "    %607 = llvm.fmul %arg0, %606  : f32\n",
+      "    %608 = llvm.fadd %607, %605  : f32\n",
+      "    %609 = llvm.mlir.constant(0.985414206 : f32) : f32\n",
+      "    %610 = llvm.fmul %arg1, %609  : f32\n",
+      "    %611 = llvm.fadd %608, %610  : f32\n",
+      "    %612 = llvm.intr.maximum(%611, %604)  : (f32, f32) -> f32\n",
+      "    %613 = llvm.mlir.constant(0.414807469 : f32) : f32\n",
+      "    %614 = llvm.fmul %612, %613  : f32\n",
+      "    %615 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %616 = llvm.mlir.constant(0.315162152 : f32) : f32\n",
+      "    %617 = llvm.mlir.constant(0.600057721 : f32) : f32\n",
+      "    %618 = llvm.fmul %arg0, %617  : f32\n",
+      "    %619 = llvm.fadd %618, %616  : f32\n",
+      "    %620 = llvm.mlir.constant(-0.313983649 : f32) : f32\n",
+      "    %621 = llvm.fmul %arg1, %620  : f32\n",
+      "    %622 = llvm.fadd %619, %621  : f32\n",
+      "    %623 = llvm.intr.maximum(%622, %615)  : (f32, f32) -> f32\n",
+      "    %624 = llvm.mlir.constant(0.355978429 : f32) : f32\n",
+      "    %625 = llvm.fmul %623, %624  : f32\n",
+      "    %626 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %627 = llvm.mlir.constant(-0.57726413 : f32) : f32\n",
+      "    %628 = llvm.fmul %arg1, %627  : f32\n",
+      "    %629 = llvm.mlir.constant(0.598408341 : f32) : f32\n",
+      "    %630 = llvm.fmul %arg0, %629  : f32\n",
+      "    %631 = llvm.mlir.constant(-0.580251634 : f32) : f32\n",
+      "    %632 = llvm.fadd %630, %631  : f32\n",
+      "    %633 = llvm.fadd %628, %632  : f32\n",
+      "    %634 = llvm.intr.maximum(%633, %626)  : (f32, f32) -> f32\n",
+      "    %635 = llvm.mlir.constant(-0.905793488 : f32) : f32\n",
+      "    %636 = llvm.fmul %634, %635  : f32\n",
+      "    %637 = llvm.mlir.constant(0.506898105 : f32) : f32\n",
+      "    %638 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %639 = llvm.mlir.constant(-0.771490633 : f32) : f32\n",
+      "    %640 = llvm.fmul %arg1, %639  : f32\n",
+      "    %641 = llvm.mlir.constant(0.114797138 : f32) : f32\n",
+      "    %642 = llvm.mlir.constant(-0.56365943 : f32) : f32\n",
+      "    %643 = llvm.fmul %arg0, %642  : f32\n",
+      "    %644 = llvm.fadd %643, %641  : f32\n",
+      "    %645 = llvm.fadd %640, %644  : f32\n",
+      "    %646 = llvm.intr.maximum(%645, %638)  : (f32, f32) -> f32\n",
+      "    %647 = llvm.fmul %646, %637  : f32\n",
+      "    %648 = llvm.mlir.constant(0.311031401 : f32) : f32\n",
+      "    %649 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %650 = llvm.mlir.constant(9.201580e-01 : f32) : f32\n",
+      "    %651 = llvm.fmul %arg0, %650  : f32\n",
+      "    %652 = llvm.mlir.constant(-0.444333524 : f32) : f32\n",
+      "    %653 = llvm.fadd %651, %652  : f32\n",
+      "    %654 = llvm.mlir.constant(0.859033763 : f32) : f32\n",
+      "    %655 = llvm.fmul %arg1, %654  : f32\n",
+      "    %656 = llvm.fadd %653, %655  : f32\n",
+      "    %657 = llvm.intr.maximum(%656, %649)  : (f32, f32) -> f32\n",
+      "    %658 = llvm.fmul %657, %648  : f32\n",
+      "    %659 = llvm.mlir.constant(-0.28366372 : f32) : f32\n",
+      "    %660 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %661 = llvm.mlir.constant(-1.00863016 : f32) : f32\n",
+      "    %662 = llvm.fmul %arg1, %661  : f32\n",
+      "    %663 = llvm.mlir.constant(-1.543290e+00 : f32) : f32\n",
+      "    %664 = llvm.mlir.constant(1.41260469 : f32) : f32\n",
+      "    %665 = llvm.fmul %arg0, %664  : f32\n",
+      "    %666 = llvm.fadd %665, %663  : f32\n",
+      "    %667 = llvm.fadd %662, %666  : f32\n",
+      "    %668 = llvm.intr.maximum(%667, %660)  : (f32, f32) -> f32\n",
+      "    %669 = llvm.fmul %668, %659  : f32\n",
+      "    %670 = llvm.mlir.constant(3.956830e-01 : f32) : f32\n",
+      "    %671 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %672 = llvm.mlir.constant(-0.710041642 : f32) : f32\n",
+      "    %673 = llvm.fmul %arg0, %672  : f32\n",
+      "    %674 = llvm.mlir.constant(-0.179663792 : f32) : f32\n",
+      "    %675 = llvm.fadd %673, %674  : f32\n",
+      "    %676 = llvm.mlir.constant(0.5115695 : f32) : f32\n",
+      "    %677 = llvm.fmul %arg1, %676  : f32\n",
+      "    %678 = llvm.fadd %675, %677  : f32\n",
+      "    %679 = llvm.intr.maximum(%678, %671)  : (f32, f32) -> f32\n",
+      "    %680 = llvm.fmul %679, %670  : f32\n",
+      "    %681 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %682 = llvm.mlir.constant(0.250564575 : f32) : f32\n",
+      "    %683 = llvm.fmul %arg1, %682  : f32\n",
+      "    %684 = llvm.mlir.constant(-0.234713525 : f32) : f32\n",
+      "    %685 = llvm.mlir.constant(-0.0761275962 : f32) : f32\n",
+      "    %686 = llvm.fmul %arg0, %685  : f32\n",
+      "    %687 = llvm.fadd %686, %684  : f32\n",
+      "    %688 = llvm.fadd %683, %687  : f32\n",
+      "    %689 = llvm.intr.maximum(%688, %681)  : (f32, f32) -> f32\n",
+      "    %690 = llvm.mlir.constant(-0.435577899 : f32) : f32\n",
+      "    %691 = llvm.fmul %689, %690  : f32\n",
+      "    %692 = llvm.mlir.constant(-0.254695028 : f32) : f32\n",
+      "    %693 = llvm.fadd %691, %692  : f32\n",
+      "    %694 = llvm.fadd %680, %693  : f32\n",
+      "    %695 = llvm.mlir.constant(-1.05535543 : f32) : f32\n",
+      "    %696 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %697 = llvm.mlir.constant(0.73282814 : f32) : f32\n",
+      "    %698 = llvm.fmul %arg1, %697  : f32\n",
+      "    %699 = llvm.mlir.constant(-0.632541954 : f32) : f32\n",
+      "    %700 = llvm.fmul %arg0, %699  : f32\n",
+      "    %701 = llvm.mlir.constant(-0.0431155674 : f32) : f32\n",
+      "    %702 = llvm.fadd %700, %701  : f32\n",
+      "    %703 = llvm.fadd %698, %702  : f32\n",
+      "    %704 = llvm.intr.maximum(%703, %696)  : (f32, f32) -> f32\n",
+      "    %705 = llvm.fmul %704, %695  : f32\n",
+      "    %706 = llvm.fadd %694, %705  : f32\n",
+      "    %707 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %708 = llvm.mlir.constant(-0.148220554 : f32) : f32\n",
+      "    %709 = llvm.mlir.constant(-0.266904861 : f32) : f32\n",
+      "    %710 = llvm.fmul %arg0, %709  : f32\n",
+      "    %711 = llvm.fadd %710, %708  : f32\n",
+      "    %712 = llvm.mlir.constant(0.591641366 : f32) : f32\n",
+      "    %713 = llvm.fmul %arg1, %712  : f32\n",
+      "    %714 = llvm.fadd %711, %713  : f32\n",
+      "    %715 = llvm.intr.maximum(%714, %707)  : (f32, f32) -> f32\n",
+      "    %716 = llvm.mlir.constant(0.598726392 : f32) : f32\n",
+      "    %717 = llvm.fmul %715, %716  : f32\n",
+      "    %718 = llvm.fadd %706, %717  : f32\n",
+      "    %719 = llvm.mlir.constant(-0.404354066 : f32) : f32\n",
+      "    %720 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %721 = llvm.mlir.constant(-0.732560634 : f32) : f32\n",
+      "    %722 = llvm.mlir.constant(0.659632384 : f32) : f32\n",
+      "    %723 = llvm.fmul %arg0, %722  : f32\n",
+      "    %724 = llvm.fadd %723, %721  : f32\n",
+      "    %725 = llvm.mlir.constant(-0.124262765 : f32) : f32\n",
+      "    %726 = llvm.fmul %arg1, %725  : f32\n",
+      "    %727 = llvm.fadd %724, %726  : f32\n",
+      "    %728 = llvm.intr.maximum(%727, %720)  : (f32, f32) -> f32\n",
+      "    %729 = llvm.fmul %728, %719  : f32\n",
+      "    %730 = llvm.fadd %718, %729  : f32\n",
+      "    %731 = llvm.fadd %669, %730  : f32\n",
+      "    %732 = llvm.fadd %658, %731  : f32\n",
+      "    %733 = llvm.mlir.constant(-0.423267365 : f32) : f32\n",
+      "    %734 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %735 = llvm.mlir.constant(0.766540825 : f32) : f32\n",
+      "    %736 = llvm.fmul %arg1, %735  : f32\n",
+      "    %737 = llvm.mlir.constant(-0.924045622 : f32) : f32\n",
+      "    %738 = llvm.fmul %arg0, %737  : f32\n",
+      "    %739 = llvm.mlir.constant(-0.259199619 : f32) : f32\n",
+      "    %740 = llvm.fadd %738, %739  : f32\n",
+      "    %741 = llvm.fadd %736, %740  : f32\n",
+      "    %742 = llvm.intr.maximum(%741, %734)  : (f32, f32) -> f32\n",
+      "    %743 = llvm.fmul %742, %733  : f32\n",
+      "    %744 = llvm.fadd %732, %743  : f32\n",
+      "    %745 = llvm.fadd %647, %744  : f32\n",
+      "    %746 = llvm.fadd %636, %745  : f32\n",
+      "    %747 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %748 = llvm.mlir.constant(0.49928996 : f32) : f32\n",
+      "    %749 = llvm.fmul %arg1, %748  : f32\n",
+      "    %750 = llvm.mlir.constant(-0.283014119 : f32) : f32\n",
+      "    %751 = llvm.fmul %arg0, %750  : f32\n",
+      "    %752 = llvm.mlir.constant(0.0311395917 : f32) : f32\n",
+      "    %753 = llvm.fadd %751, %752  : f32\n",
+      "    %754 = llvm.fadd %749, %753  : f32\n",
+      "    %755 = llvm.intr.maximum(%754, %747)  : (f32, f32) -> f32\n",
+      "    %756 = llvm.mlir.constant(0.416599959 : f32) : f32\n",
+      "    %757 = llvm.fmul %755, %756  : f32\n",
+      "    %758 = llvm.fadd %746, %757  : f32\n",
+      "    %759 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %760 = llvm.mlir.constant(0.58700037 : f32) : f32\n",
+      "    %761 = llvm.fmul %arg1, %760  : f32\n",
+      "    %762 = llvm.mlir.constant(-0.0791633725 : f32) : f32\n",
+      "    %763 = llvm.fmul %arg0, %762  : f32\n",
+      "    %764 = llvm.mlir.constant(-0.478744268 : f32) : f32\n",
+      "    %765 = llvm.fadd %763, %764  : f32\n",
+      "    %766 = llvm.fadd %761, %765  : f32\n",
+      "    %767 = llvm.intr.maximum(%766, %759)  : (f32, f32) -> f32\n",
+      "    %768 = llvm.mlir.constant(-0.938638329 : f32) : f32\n",
+      "    %769 = llvm.fmul %767, %768  : f32\n",
+      "    %770 = llvm.fadd %758, %769  : f32\n",
+      "    %771 = llvm.fadd %625, %770  : f32\n",
+      "    %772 = llvm.fadd %614, %771  : f32\n",
+      "    %773 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %774 = llvm.mlir.constant(-0.0821817442 : f32) : f32\n",
+      "    %775 = llvm.fmul %arg1, %774  : f32\n",
+      "    %776 = llvm.mlir.constant(-0.732010245 : f32) : f32\n",
+      "    %777 = llvm.mlir.constant(-0.354400456 : f32) : f32\n",
+      "    %778 = llvm.fmul %arg0, %777  : f32\n",
+      "    %779 = llvm.fadd %778, %776  : f32\n",
+      "    %780 = llvm.fadd %775, %779  : f32\n",
+      "    %781 = llvm.intr.maximum(%780, %773)  : (f32, f32) -> f32\n",
+      "    %782 = llvm.mlir.constant(0.238994092 : f32) : f32\n",
+      "    %783 = llvm.fmul %781, %782  : f32\n",
+      "    %784 = llvm.fadd %772, %783  : f32\n",
+      "    %785 = llvm.fadd %603, %784  : f32\n",
+      "    %786 = llvm.intr.maximum(%785, %592)  : (f32, f32) -> f32\n",
+      "    %787 = llvm.fmul %786, %591  : f32\n",
+      "    %788 = llvm.mlir.constant(-0.347347945 : f32) : f32\n",
+      "    %789 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %790 = llvm.mlir.constant(-0.236172944 : f32) : f32\n",
+      "    %791 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %792 = llvm.mlir.constant(-0.0821817442 : f32) : f32\n",
+      "    %793 = llvm.fmul %arg1, %792  : f32\n",
+      "    %794 = llvm.mlir.constant(-0.732010245 : f32) : f32\n",
+      "    %795 = llvm.mlir.constant(-0.354400456 : f32) : f32\n",
+      "    %796 = llvm.fmul %arg0, %795  : f32\n",
+      "    %797 = llvm.fadd %796, %794  : f32\n",
+      "    %798 = llvm.fadd %793, %797  : f32\n",
+      "    %799 = llvm.intr.maximum(%798, %791)  : (f32, f32) -> f32\n",
+      "    %800 = llvm.fmul %799, %790  : f32\n",
+      "    %801 = llvm.mlir.constant(-0.535227895 : f32) : f32\n",
+      "    %802 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %803 = llvm.mlir.constant(0.49928996 : f32) : f32\n",
+      "    %804 = llvm.fmul %arg1, %803  : f32\n",
+      "    %805 = llvm.mlir.constant(-0.283014119 : f32) : f32\n",
+      "    %806 = llvm.fmul %arg0, %805  : f32\n",
+      "    %807 = llvm.mlir.constant(0.0311395917 : f32) : f32\n",
+      "    %808 = llvm.fadd %806, %807  : f32\n",
+      "    %809 = llvm.fadd %804, %808  : f32\n",
+      "    %810 = llvm.intr.maximum(%809, %802)  : (f32, f32) -> f32\n",
+      "    %811 = llvm.fmul %810, %801  : f32\n",
+      "    %812 = llvm.mlir.constant(-0.999428331 : f32) : f32\n",
+      "    %813 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %814 = llvm.mlir.constant(-0.57726413 : f32) : f32\n",
+      "    %815 = llvm.fmul %arg1, %814  : f32\n",
+      "    %816 = llvm.mlir.constant(0.598408341 : f32) : f32\n",
+      "    %817 = llvm.fmul %arg0, %816  : f32\n",
+      "    %818 = llvm.mlir.constant(-0.580251634 : f32) : f32\n",
+      "    %819 = llvm.fadd %817, %818  : f32\n",
+      "    %820 = llvm.fadd %815, %819  : f32\n",
+      "    %821 = llvm.intr.maximum(%820, %813)  : (f32, f32) -> f32\n",
+      "    %822 = llvm.fmul %821, %812  : f32\n",
+      "    %823 = llvm.mlir.constant(-0.503325164 : f32) : f32\n",
+      "    %824 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %825 = llvm.mlir.constant(0.766540825 : f32) : f32\n",
+      "    %826 = llvm.fmul %arg1, %825  : f32\n",
+      "    %827 = llvm.mlir.constant(-0.924045622 : f32) : f32\n",
+      "    %828 = llvm.fmul %arg0, %827  : f32\n",
+      "    %829 = llvm.mlir.constant(-0.259199619 : f32) : f32\n",
+      "    %830 = llvm.fadd %828, %829  : f32\n",
+      "    %831 = llvm.fadd %826, %830  : f32\n",
+      "    %832 = llvm.intr.maximum(%831, %824)  : (f32, f32) -> f32\n",
+      "    %833 = llvm.fmul %832, %823  : f32\n",
+      "    %834 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %835 = llvm.mlir.constant(-0.148220554 : f32) : f32\n",
+      "    %836 = llvm.mlir.constant(-0.266904861 : f32) : f32\n",
+      "    %837 = llvm.fmul %arg0, %836  : f32\n",
+      "    %838 = llvm.fadd %837, %835  : f32\n",
+      "    %839 = llvm.mlir.constant(0.591641366 : f32) : f32\n",
+      "    %840 = llvm.fmul %arg1, %839  : f32\n",
+      "    %841 = llvm.fadd %838, %840  : f32\n",
+      "    %842 = llvm.intr.maximum(%841, %834)  : (f32, f32) -> f32\n",
+      "    %843 = llvm.mlir.constant(-0.831829547 : f32) : f32\n",
+      "    %844 = llvm.fmul %842, %843  : f32\n",
+      "    %845 = llvm.mlir.constant(-0.212834269 : f32) : f32\n",
+      "    %846 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %847 = llvm.mlir.constant(0.250564575 : f32) : f32\n",
+      "    %848 = llvm.fmul %arg1, %847  : f32\n",
+      "    %849 = llvm.mlir.constant(-0.234713525 : f32) : f32\n",
+      "    %850 = llvm.mlir.constant(-0.0761275962 : f32) : f32\n",
+      "    %851 = llvm.fmul %arg0, %850  : f32\n",
+      "    %852 = llvm.fadd %851, %849  : f32\n",
+      "    %853 = llvm.fadd %848, %852  : f32\n",
+      "    %854 = llvm.intr.maximum(%853, %846)  : (f32, f32) -> f32\n",
+      "    %855 = llvm.mlir.constant(0.651921689 : f32) : f32\n",
+      "    %856 = llvm.fmul %854, %855  : f32\n",
+      "    %857 = llvm.fadd %856, %845  : f32\n",
+      "    %858 = llvm.mlir.constant(-0.678586125 : f32) : f32\n",
+      "    %859 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %860 = llvm.mlir.constant(-0.710041642 : f32) : f32\n",
+      "    %861 = llvm.fmul %arg0, %860  : f32\n",
+      "    %862 = llvm.mlir.constant(-0.179663792 : f32) : f32\n",
+      "    %863 = llvm.fadd %861, %862  : f32\n",
+      "    %864 = llvm.mlir.constant(0.5115695 : f32) : f32\n",
+      "    %865 = llvm.fmul %arg1, %864  : f32\n",
+      "    %866 = llvm.fadd %863, %865  : f32\n",
+      "    %867 = llvm.intr.maximum(%866, %859)  : (f32, f32) -> f32\n",
+      "    %868 = llvm.fmul %867, %858  : f32\n",
+      "    %869 = llvm.fadd %857, %868  : f32\n",
+      "    %870 = llvm.mlir.constant(-0.59961921 : f32) : f32\n",
+      "    %871 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %872 = llvm.mlir.constant(0.73282814 : f32) : f32\n",
+      "    %873 = llvm.fmul %arg1, %872  : f32\n",
+      "    %874 = llvm.mlir.constant(-0.632541954 : f32) : f32\n",
+      "    %875 = llvm.fmul %arg0, %874  : f32\n",
+      "    %876 = llvm.mlir.constant(-0.0431155674 : f32) : f32\n",
+      "    %877 = llvm.fadd %875, %876  : f32\n",
+      "    %878 = llvm.fadd %873, %877  : f32\n",
+      "    %879 = llvm.intr.maximum(%878, %871)  : (f32, f32) -> f32\n",
+      "    %880 = llvm.fmul %879, %870  : f32\n",
+      "    %881 = llvm.fadd %869, %880  : f32\n",
+      "    %882 = llvm.fadd %844, %881  : f32\n",
+      "    %883 = llvm.mlir.constant(-0.151730344 : f32) : f32\n",
+      "    %884 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %885 = llvm.mlir.constant(-0.732560634 : f32) : f32\n",
+      "    %886 = llvm.mlir.constant(0.659632384 : f32) : f32\n",
+      "    %887 = llvm.fmul %arg0, %886  : f32\n",
+      "    %888 = llvm.fadd %887, %885  : f32\n",
+      "    %889 = llvm.mlir.constant(-0.124262765 : f32) : f32\n",
+      "    %890 = llvm.fmul %arg1, %889  : f32\n",
+      "    %891 = llvm.fadd %888, %890  : f32\n",
+      "    %892 = llvm.intr.maximum(%891, %884)  : (f32, f32) -> f32\n",
+      "    %893 = llvm.fmul %892, %883  : f32\n",
+      "    %894 = llvm.fadd %882, %893  : f32\n",
+      "    %895 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %896 = llvm.mlir.constant(-1.00863016 : f32) : f32\n",
+      "    %897 = llvm.fmul %arg1, %896  : f32\n",
+      "    %898 = llvm.mlir.constant(-1.543290e+00 : f32) : f32\n",
+      "    %899 = llvm.mlir.constant(1.41260469 : f32) : f32\n",
+      "    %900 = llvm.fmul %arg0, %899  : f32\n",
+      "    %901 = llvm.fadd %900, %898  : f32\n",
+      "    %902 = llvm.fadd %897, %901  : f32\n",
+      "    %903 = llvm.intr.maximum(%902, %895)  : (f32, f32) -> f32\n",
+      "    %904 = llvm.mlir.constant(0.512547851 : f32) : f32\n",
+      "    %905 = llvm.fmul %903, %904  : f32\n",
+      "    %906 = llvm.fadd %894, %905  : f32\n",
+      "    %907 = llvm.mlir.constant(0.118775733 : f32) : f32\n",
+      "    %908 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %909 = llvm.mlir.constant(9.201580e-01 : f32) : f32\n",
+      "    %910 = llvm.fmul %arg0, %909  : f32\n",
+      "    %911 = llvm.mlir.constant(-0.444333524 : f32) : f32\n",
+      "    %912 = llvm.fadd %910, %911  : f32\n",
+      "    %913 = llvm.mlir.constant(0.859033763 : f32) : f32\n",
+      "    %914 = llvm.fmul %arg1, %913  : f32\n",
+      "    %915 = llvm.fadd %912, %914  : f32\n",
+      "    %916 = llvm.intr.maximum(%915, %908)  : (f32, f32) -> f32\n",
+      "    %917 = llvm.fmul %916, %907  : f32\n",
+      "    %918 = llvm.fadd %906, %917  : f32\n",
+      "    %919 = llvm.fadd %833, %918  : f32\n",
+      "    %920 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %921 = llvm.mlir.constant(-0.771490633 : f32) : f32\n",
+      "    %922 = llvm.fmul %arg1, %921  : f32\n",
+      "    %923 = llvm.mlir.constant(0.114797138 : f32) : f32\n",
+      "    %924 = llvm.mlir.constant(-0.56365943 : f32) : f32\n",
+      "    %925 = llvm.fmul %arg0, %924  : f32\n",
+      "    %926 = llvm.fadd %925, %923  : f32\n",
+      "    %927 = llvm.fadd %922, %926  : f32\n",
+      "    %928 = llvm.intr.maximum(%927, %920)  : (f32, f32) -> f32\n",
+      "    %929 = llvm.mlir.constant(7.980340e-01 : f32) : f32\n",
+      "    %930 = llvm.fmul %928, %929  : f32\n",
+      "    %931 = llvm.fadd %919, %930  : f32\n",
+      "    %932 = llvm.fadd %822, %931  : f32\n",
+      "    %933 = llvm.fadd %811, %932  : f32\n",
+      "    %934 = llvm.mlir.constant(0.433179587 : f32) : f32\n",
+      "    %935 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %936 = llvm.mlir.constant(0.58700037 : f32) : f32\n",
+      "    %937 = llvm.fmul %arg1, %936  : f32\n",
+      "    %938 = llvm.mlir.constant(-0.0791633725 : f32) : f32\n",
+      "    %939 = llvm.fmul %arg0, %938  : f32\n",
+      "    %940 = llvm.mlir.constant(-0.478744268 : f32) : f32\n",
+      "    %941 = llvm.fadd %939, %940  : f32\n",
+      "    %942 = llvm.fadd %937, %941  : f32\n",
+      "    %943 = llvm.intr.maximum(%942, %935)  : (f32, f32) -> f32\n",
+      "    %944 = llvm.fmul %943, %934  : f32\n",
+      "    %945 = llvm.fadd %933, %944  : f32\n",
+      "    %946 = llvm.mlir.constant(-0.503125131 : f32) : f32\n",
+      "    %947 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %948 = llvm.mlir.constant(0.315162152 : f32) : f32\n",
+      "    %949 = llvm.mlir.constant(0.600057721 : f32) : f32\n",
+      "    %950 = llvm.fmul %arg0, %949  : f32\n",
+      "    %951 = llvm.fadd %950, %948  : f32\n",
+      "    %952 = llvm.mlir.constant(-0.313983649 : f32) : f32\n",
+      "    %953 = llvm.fmul %arg1, %952  : f32\n",
+      "    %954 = llvm.fadd %951, %953  : f32\n",
+      "    %955 = llvm.intr.maximum(%954, %947)  : (f32, f32) -> f32\n",
+      "    %956 = llvm.fmul %955, %946  : f32\n",
+      "    %957 = llvm.fadd %945, %956  : f32\n",
+      "    %958 = llvm.mlir.constant(0.109583691 : f32) : f32\n",
+      "    %959 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %960 = llvm.mlir.constant(-0.169446096 : f32) : f32\n",
+      "    %961 = llvm.mlir.constant(-0.215495735 : f32) : f32\n",
+      "    %962 = llvm.fmul %arg0, %961  : f32\n",
+      "    %963 = llvm.fadd %962, %960  : f32\n",
+      "    %964 = llvm.mlir.constant(0.985414206 : f32) : f32\n",
+      "    %965 = llvm.fmul %arg1, %964  : f32\n",
+      "    %966 = llvm.fadd %963, %965  : f32\n",
+      "    %967 = llvm.intr.maximum(%966, %959)  : (f32, f32) -> f32\n",
+      "    %968 = llvm.fmul %967, %958  : f32\n",
+      "    %969 = llvm.fadd %957, %968  : f32\n",
+      "    %970 = llvm.fadd %800, %969  : f32\n",
+      "    %971 = llvm.mlir.constant(-0.653223812 : f32) : f32\n",
+      "    %972 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %973 = llvm.mlir.constant(-0.217542693 : f32) : f32\n",
+      "    %974 = llvm.mlir.constant(0.876379132 : f32) : f32\n",
+      "    %975 = llvm.fmul %arg0, %974  : f32\n",
+      "    %976 = llvm.fadd %975, %973  : f32\n",
+      "    %977 = llvm.mlir.constant(0.950005471 : f32) : f32\n",
+      "    %978 = llvm.fmul %arg1, %977  : f32\n",
+      "    %979 = llvm.fadd %976, %978  : f32\n",
+      "    %980 = llvm.intr.maximum(%979, %972)  : (f32, f32) -> f32\n",
+      "    %981 = llvm.fmul %980, %971  : f32\n",
+      "    %982 = llvm.fadd %970, %981  : f32\n",
+      "    %983 = llvm.intr.maximum(%982, %789)  : (f32, f32) -> f32\n",
+      "    %984 = llvm.fmul %983, %788  : f32\n",
+      "    %985 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %986 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %987 = llvm.mlir.constant(-0.217542693 : f32) : f32\n",
+      "    %988 = llvm.mlir.constant(0.876379132 : f32) : f32\n",
+      "    %989 = llvm.fmul %arg0, %988  : f32\n",
+      "    %990 = llvm.fadd %989, %987  : f32\n",
+      "    %991 = llvm.mlir.constant(0.950005471 : f32) : f32\n",
+      "    %992 = llvm.fmul %arg1, %991  : f32\n",
+      "    %993 = llvm.fadd %990, %992  : f32\n",
+      "    %994 = llvm.intr.maximum(%993, %986)  : (f32, f32) -> f32\n",
+      "    %995 = llvm.mlir.constant(-0.663493276 : f32) : f32\n",
+      "    %996 = llvm.fmul %994, %995  : f32\n",
+      "    %997 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %998 = llvm.mlir.constant(-0.169446096 : f32) : f32\n",
+      "    %999 = llvm.mlir.constant(-0.215495735 : f32) : f32\n",
+      "    %1000 = llvm.fmul %arg0, %999  : f32\n",
+      "    %1001 = llvm.fadd %1000, %998  : f32\n",
+      "    %1002 = llvm.mlir.constant(0.985414206 : f32) : f32\n",
+      "    %1003 = llvm.fmul %arg1, %1002  : f32\n",
+      "    %1004 = llvm.fadd %1001, %1003  : f32\n",
+      "    %1005 = llvm.intr.maximum(%1004, %997)  : (f32, f32) -> f32\n",
+      "    %1006 = llvm.mlir.constant(-0.877457201 : f32) : f32\n",
+      "    %1007 = llvm.fmul %1005, %1006  : f32\n",
+      "    %1008 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1009 = llvm.mlir.constant(0.58700037 : f32) : f32\n",
+      "    %1010 = llvm.fmul %arg1, %1009  : f32\n",
+      "    %1011 = llvm.mlir.constant(-0.0791633725 : f32) : f32\n",
+      "    %1012 = llvm.fmul %arg0, %1011  : f32\n",
+      "    %1013 = llvm.mlir.constant(-0.478744268 : f32) : f32\n",
+      "    %1014 = llvm.fadd %1012, %1013  : f32\n",
+      "    %1015 = llvm.fadd %1010, %1014  : f32\n",
+      "    %1016 = llvm.intr.maximum(%1015, %1008)  : (f32, f32) -> f32\n",
+      "    %1017 = llvm.mlir.constant(0.80765289 : f32) : f32\n",
+      "    %1018 = llvm.fmul %1016, %1017  : f32\n",
+      "    %1019 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1020 = llvm.mlir.constant(-0.57726413 : f32) : f32\n",
+      "    %1021 = llvm.fmul %arg1, %1020  : f32\n",
+      "    %1022 = llvm.mlir.constant(0.598408341 : f32) : f32\n",
+      "    %1023 = llvm.fmul %arg0, %1022  : f32\n",
+      "    %1024 = llvm.mlir.constant(-0.580251634 : f32) : f32\n",
+      "    %1025 = llvm.fadd %1023, %1024  : f32\n",
+      "    %1026 = llvm.fadd %1021, %1025  : f32\n",
+      "    %1027 = llvm.intr.maximum(%1026, %1019)  : (f32, f32) -> f32\n",
+      "    %1028 = llvm.mlir.constant(0.220904842 : f32) : f32\n",
+      "    %1029 = llvm.fmul %1027, %1028  : f32\n",
+      "    %1030 = llvm.mlir.constant(1.06885493 : f32) : f32\n",
+      "    %1031 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1032 = llvm.mlir.constant(0.766540825 : f32) : f32\n",
+      "    %1033 = llvm.fmul %arg1, %1032  : f32\n",
+      "    %1034 = llvm.mlir.constant(-0.924045622 : f32) : f32\n",
+      "    %1035 = llvm.fmul %arg0, %1034  : f32\n",
+      "    %1036 = llvm.mlir.constant(-0.259199619 : f32) : f32\n",
+      "    %1037 = llvm.fadd %1035, %1036  : f32\n",
+      "    %1038 = llvm.fadd %1033, %1037  : f32\n",
+      "    %1039 = llvm.intr.maximum(%1038, %1031)  : (f32, f32) -> f32\n",
+      "    %1040 = llvm.fmul %1039, %1030  : f32\n",
+      "    %1041 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1042 = llvm.mlir.constant(-0.148220554 : f32) : f32\n",
+      "    %1043 = llvm.mlir.constant(-0.266904861 : f32) : f32\n",
+      "    %1044 = llvm.fmul %arg0, %1043  : f32\n",
+      "    %1045 = llvm.fadd %1044, %1042  : f32\n",
+      "    %1046 = llvm.mlir.constant(0.591641366 : f32) : f32\n",
+      "    %1047 = llvm.fmul %arg1, %1046  : f32\n",
+      "    %1048 = llvm.fadd %1045, %1047  : f32\n",
+      "    %1049 = llvm.intr.maximum(%1048, %1041)  : (f32, f32) -> f32\n",
+      "    %1050 = llvm.mlir.constant(0.330533355 : f32) : f32\n",
+      "    %1051 = llvm.fmul %1049, %1050  : f32\n",
+      "    %1052 = llvm.mlir.constant(0.408399701 : f32) : f32\n",
+      "    %1053 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1054 = llvm.mlir.constant(0.73282814 : f32) : f32\n",
+      "    %1055 = llvm.fmul %arg1, %1054  : f32\n",
+      "    %1056 = llvm.mlir.constant(-0.632541954 : f32) : f32\n",
+      "    %1057 = llvm.fmul %arg0, %1056  : f32\n",
+      "    %1058 = llvm.mlir.constant(-0.0431155674 : f32) : f32\n",
+      "    %1059 = llvm.fadd %1057, %1058  : f32\n",
+      "    %1060 = llvm.fadd %1055, %1059  : f32\n",
+      "    %1061 = llvm.intr.maximum(%1060, %1053)  : (f32, f32) -> f32\n",
+      "    %1062 = llvm.fmul %1061, %1052  : f32\n",
+      "    %1063 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1064 = llvm.mlir.constant(0.250564575 : f32) : f32\n",
+      "    %1065 = llvm.fmul %arg1, %1064  : f32\n",
+      "    %1066 = llvm.mlir.constant(-0.234713525 : f32) : f32\n",
+      "    %1067 = llvm.mlir.constant(-0.0761275962 : f32) : f32\n",
+      "    %1068 = llvm.fmul %arg0, %1067  : f32\n",
+      "    %1069 = llvm.fadd %1068, %1066  : f32\n",
+      "    %1070 = llvm.fadd %1065, %1069  : f32\n",
+      "    %1071 = llvm.intr.maximum(%1070, %1063)  : (f32, f32) -> f32\n",
+      "    %1072 = llvm.mlir.constant(-0.00853481329 : f32) : f32\n",
+      "    %1073 = llvm.fmul %1071, %1072  : f32\n",
+      "    %1074 = llvm.mlir.constant(-0.186202839 : f32) : f32\n",
+      "    %1075 = llvm.fadd %1073, %1074  : f32\n",
+      "    %1076 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1077 = llvm.mlir.constant(-0.710041642 : f32) : f32\n",
+      "    %1078 = llvm.fmul %arg0, %1077  : f32\n",
+      "    %1079 = llvm.mlir.constant(-0.179663792 : f32) : f32\n",
+      "    %1080 = llvm.fadd %1078, %1079  : f32\n",
+      "    %1081 = llvm.mlir.constant(0.5115695 : f32) : f32\n",
+      "    %1082 = llvm.fmul %arg1, %1081  : f32\n",
+      "    %1083 = llvm.fadd %1080, %1082  : f32\n",
+      "    %1084 = llvm.intr.maximum(%1083, %1076)  : (f32, f32) -> f32\n",
+      "    %1085 = llvm.mlir.constant(0.248254791 : f32) : f32\n",
+      "    %1086 = llvm.fmul %1084, %1085  : f32\n",
+      "    %1087 = llvm.fadd %1075, %1086  : f32\n",
+      "    %1088 = llvm.fadd %1062, %1087  : f32\n",
+      "    %1089 = llvm.fadd %1051, %1088  : f32\n",
+      "    %1090 = llvm.mlir.constant(-0.107261449 : f32) : f32\n",
+      "    %1091 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1092 = llvm.mlir.constant(-0.732560634 : f32) : f32\n",
+      "    %1093 = llvm.mlir.constant(0.659632384 : f32) : f32\n",
+      "    %1094 = llvm.fmul %arg0, %1093  : f32\n",
+      "    %1095 = llvm.fadd %1094, %1092  : f32\n",
+      "    %1096 = llvm.mlir.constant(-0.124262765 : f32) : f32\n",
+      "    %1097 = llvm.fmul %arg1, %1096  : f32\n",
+      "    %1098 = llvm.fadd %1095, %1097  : f32\n",
+      "    %1099 = llvm.intr.maximum(%1098, %1091)  : (f32, f32) -> f32\n",
+      "    %1100 = llvm.fmul %1099, %1090  : f32\n",
+      "    %1101 = llvm.fadd %1089, %1100  : f32\n",
+      "    %1102 = llvm.mlir.constant(-1.0823977 : f32) : f32\n",
+      "    %1103 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1104 = llvm.mlir.constant(-1.00863016 : f32) : f32\n",
+      "    %1105 = llvm.fmul %arg1, %1104  : f32\n",
+      "    %1106 = llvm.mlir.constant(-1.543290e+00 : f32) : f32\n",
+      "    %1107 = llvm.mlir.constant(1.41260469 : f32) : f32\n",
+      "    %1108 = llvm.fmul %arg0, %1107  : f32\n",
+      "    %1109 = llvm.fadd %1108, %1106  : f32\n",
+      "    %1110 = llvm.fadd %1105, %1109  : f32\n",
+      "    %1111 = llvm.intr.maximum(%1110, %1103)  : (f32, f32) -> f32\n",
+      "    %1112 = llvm.fmul %1111, %1102  : f32\n",
+      "    %1113 = llvm.fadd %1101, %1112  : f32\n",
+      "    %1114 = llvm.mlir.constant(-0.691787481 : f32) : f32\n",
+      "    %1115 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1116 = llvm.mlir.constant(9.201580e-01 : f32) : f32\n",
+      "    %1117 = llvm.fmul %arg0, %1116  : f32\n",
+      "    %1118 = llvm.mlir.constant(-0.444333524 : f32) : f32\n",
+      "    %1119 = llvm.fadd %1117, %1118  : f32\n",
+      "    %1120 = llvm.mlir.constant(0.859033763 : f32) : f32\n",
+      "    %1121 = llvm.fmul %arg1, %1120  : f32\n",
+      "    %1122 = llvm.fadd %1119, %1121  : f32\n",
+      "    %1123 = llvm.intr.maximum(%1122, %1115)  : (f32, f32) -> f32\n",
+      "    %1124 = llvm.fmul %1123, %1114  : f32\n",
+      "    %1125 = llvm.fadd %1113, %1124  : f32\n",
+      "    %1126 = llvm.fadd %1040, %1125  : f32\n",
+      "    %1127 = llvm.mlir.constant(0.822673141 : f32) : f32\n",
+      "    %1128 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1129 = llvm.mlir.constant(-0.771490633 : f32) : f32\n",
+      "    %1130 = llvm.fmul %arg1, %1129  : f32\n",
+      "    %1131 = llvm.mlir.constant(0.114797138 : f32) : f32\n",
+      "    %1132 = llvm.mlir.constant(-0.56365943 : f32) : f32\n",
+      "    %1133 = llvm.fmul %arg0, %1132  : f32\n",
+      "    %1134 = llvm.fadd %1133, %1131  : f32\n",
+      "    %1135 = llvm.fadd %1130, %1134  : f32\n",
+      "    %1136 = llvm.intr.maximum(%1135, %1128)  : (f32, f32) -> f32\n",
+      "    %1137 = llvm.fmul %1136, %1127  : f32\n",
+      "    %1138 = llvm.fadd %1126, %1137  : f32\n",
+      "    %1139 = llvm.fadd %1029, %1138  : f32\n",
+      "    %1140 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1141 = llvm.mlir.constant(0.49928996 : f32) : f32\n",
+      "    %1142 = llvm.fmul %arg1, %1141  : f32\n",
+      "    %1143 = llvm.mlir.constant(-0.283014119 : f32) : f32\n",
+      "    %1144 = llvm.fmul %arg0, %1143  : f32\n",
+      "    %1145 = llvm.mlir.constant(0.0311395917 : f32) : f32\n",
+      "    %1146 = llvm.fadd %1144, %1145  : f32\n",
+      "    %1147 = llvm.fadd %1142, %1146  : f32\n",
+      "    %1148 = llvm.intr.maximum(%1147, %1140)  : (f32, f32) -> f32\n",
+      "    %1149 = llvm.mlir.constant(0.276456654 : f32) : f32\n",
+      "    %1150 = llvm.fmul %1148, %1149  : f32\n",
+      "    %1151 = llvm.fadd %1139, %1150  : f32\n",
+      "    %1152 = llvm.fadd %1018, %1151  : f32\n",
+      "    %1153 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1154 = llvm.mlir.constant(0.315162152 : f32) : f32\n",
+      "    %1155 = llvm.mlir.constant(0.600057721 : f32) : f32\n",
+      "    %1156 = llvm.fmul %arg0, %1155  : f32\n",
+      "    %1157 = llvm.fadd %1156, %1154  : f32\n",
+      "    %1158 = llvm.mlir.constant(-0.313983649 : f32) : f32\n",
+      "    %1159 = llvm.fmul %arg1, %1158  : f32\n",
+      "    %1160 = llvm.fadd %1157, %1159  : f32\n",
+      "    %1161 = llvm.intr.maximum(%1160, %1153)  : (f32, f32) -> f32\n",
+      "    %1162 = llvm.mlir.constant(0.323375344 : f32) : f32\n",
+      "    %1163 = llvm.fmul %1161, %1162  : f32\n",
+      "    %1164 = llvm.fadd %1152, %1163  : f32\n",
+      "    %1165 = llvm.fadd %1007, %1164  : f32\n",
+      "    %1166 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1167 = llvm.mlir.constant(-0.0821817442 : f32) : f32\n",
+      "    %1168 = llvm.fmul %arg1, %1167  : f32\n",
+      "    %1169 = llvm.mlir.constant(-0.732010245 : f32) : f32\n",
+      "    %1170 = llvm.mlir.constant(-0.354400456 : f32) : f32\n",
+      "    %1171 = llvm.fmul %arg0, %1170  : f32\n",
+      "    %1172 = llvm.fadd %1171, %1169  : f32\n",
+      "    %1173 = llvm.fadd %1168, %1172  : f32\n",
+      "    %1174 = llvm.intr.maximum(%1173, %1166)  : (f32, f32) -> f32\n",
+      "    %1175 = llvm.mlir.constant(0.500582635 : f32) : f32\n",
+      "    %1176 = llvm.fmul %1174, %1175  : f32\n",
+      "    %1177 = llvm.fadd %1165, %1176  : f32\n",
+      "    %1178 = llvm.fadd %996, %1177  : f32\n",
+      "    %1179 = llvm.intr.maximum(%1178, %985)  : (f32, f32) -> f32\n",
+      "    %1180 = llvm.mlir.constant(-0.715305567 : f32) : f32\n",
+      "    %1181 = llvm.fmul %1179, %1180  : f32\n",
+      "    %1182 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1183 = llvm.mlir.constant(-0.287250042 : f32) : f32\n",
+      "    %1184 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1185 = llvm.mlir.constant(-0.217542693 : f32) : f32\n",
+      "    %1186 = llvm.mlir.constant(0.876379132 : f32) : f32\n",
+      "    %1187 = llvm.fmul %arg0, %1186  : f32\n",
+      "    %1188 = llvm.fadd %1187, %1185  : f32\n",
+      "    %1189 = llvm.mlir.constant(0.950005471 : f32) : f32\n",
+      "    %1190 = llvm.fmul %arg1, %1189  : f32\n",
+      "    %1191 = llvm.fadd %1188, %1190  : f32\n",
+      "    %1192 = llvm.intr.maximum(%1191, %1184)  : (f32, f32) -> f32\n",
+      "    %1193 = llvm.fmul %1192, %1183  : f32\n",
+      "    %1194 = llvm.mlir.constant(0.0688674822 : f32) : f32\n",
+      "    %1195 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1196 = llvm.mlir.constant(-0.169446096 : f32) : f32\n",
+      "    %1197 = llvm.mlir.constant(-0.215495735 : f32) : f32\n",
+      "    %1198 = llvm.fmul %arg0, %1197  : f32\n",
+      "    %1199 = llvm.fadd %1198, %1196  : f32\n",
+      "    %1200 = llvm.mlir.constant(0.985414206 : f32) : f32\n",
+      "    %1201 = llvm.fmul %arg1, %1200  : f32\n",
+      "    %1202 = llvm.fadd %1199, %1201  : f32\n",
+      "    %1203 = llvm.intr.maximum(%1202, %1195)  : (f32, f32) -> f32\n",
+      "    %1204 = llvm.fmul %1203, %1194  : f32\n",
+      "    %1205 = llvm.mlir.constant(0.484879285 : f32) : f32\n",
+      "    %1206 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1207 = llvm.mlir.constant(0.58700037 : f32) : f32\n",
+      "    %1208 = llvm.fmul %arg1, %1207  : f32\n",
+      "    %1209 = llvm.mlir.constant(-0.0791633725 : f32) : f32\n",
+      "    %1210 = llvm.fmul %arg0, %1209  : f32\n",
+      "    %1211 = llvm.mlir.constant(-0.478744268 : f32) : f32\n",
+      "    %1212 = llvm.fadd %1210, %1211  : f32\n",
+      "    %1213 = llvm.fadd %1208, %1212  : f32\n",
+      "    %1214 = llvm.intr.maximum(%1213, %1206)  : (f32, f32) -> f32\n",
+      "    %1215 = llvm.fmul %1214, %1205  : f32\n",
+      "    %1216 = llvm.mlir.constant(-0.303540111 : f32) : f32\n",
+      "    %1217 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1218 = llvm.mlir.constant(0.49928996 : f32) : f32\n",
+      "    %1219 = llvm.fmul %arg1, %1218  : f32\n",
+      "    %1220 = llvm.mlir.constant(-0.283014119 : f32) : f32\n",
+      "    %1221 = llvm.fmul %arg0, %1220  : f32\n",
+      "    %1222 = llvm.mlir.constant(0.0311395917 : f32) : f32\n",
+      "    %1223 = llvm.fadd %1221, %1222  : f32\n",
+      "    %1224 = llvm.fadd %1219, %1223  : f32\n",
+      "    %1225 = llvm.intr.maximum(%1224, %1217)  : (f32, f32) -> f32\n",
+      "    %1226 = llvm.fmul %1225, %1216  : f32\n",
+      "    %1227 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1228 = llvm.mlir.constant(-0.771490633 : f32) : f32\n",
+      "    %1229 = llvm.fmul %arg1, %1228  : f32\n",
+      "    %1230 = llvm.mlir.constant(0.114797138 : f32) : f32\n",
+      "    %1231 = llvm.mlir.constant(-0.56365943 : f32) : f32\n",
+      "    %1232 = llvm.fmul %arg0, %1231  : f32\n",
+      "    %1233 = llvm.fadd %1232, %1230  : f32\n",
+      "    %1234 = llvm.fadd %1229, %1233  : f32\n",
+      "    %1235 = llvm.intr.maximum(%1234, %1227)  : (f32, f32) -> f32\n",
+      "    %1236 = llvm.mlir.constant(-0.848940789 : f32) : f32\n",
+      "    %1237 = llvm.fmul %1235, %1236  : f32\n",
+      "    %1238 = llvm.mlir.constant(-0.568716347 : f32) : f32\n",
+      "    %1239 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1240 = llvm.mlir.constant(9.201580e-01 : f32) : f32\n",
+      "    %1241 = llvm.fmul %arg0, %1240  : f32\n",
+      "    %1242 = llvm.mlir.constant(-0.444333524 : f32) : f32\n",
+      "    %1243 = llvm.fadd %1241, %1242  : f32\n",
+      "    %1244 = llvm.mlir.constant(0.859033763 : f32) : f32\n",
+      "    %1245 = llvm.fmul %arg1, %1244  : f32\n",
+      "    %1246 = llvm.fadd %1243, %1245  : f32\n",
+      "    %1247 = llvm.intr.maximum(%1246, %1239)  : (f32, f32) -> f32\n",
+      "    %1248 = llvm.fmul %1247, %1238  : f32\n",
+      "    %1249 = llvm.mlir.constant(0.284855902 : f32) : f32\n",
+      "    %1250 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1251 = llvm.mlir.constant(-0.732560634 : f32) : f32\n",
+      "    %1252 = llvm.mlir.constant(0.659632384 : f32) : f32\n",
+      "    %1253 = llvm.fmul %arg0, %1252  : f32\n",
+      "    %1254 = llvm.fadd %1253, %1251  : f32\n",
+      "    %1255 = llvm.mlir.constant(-0.124262765 : f32) : f32\n",
+      "    %1256 = llvm.fmul %arg1, %1255  : f32\n",
+      "    %1257 = llvm.fadd %1254, %1256  : f32\n",
+      "    %1258 = llvm.intr.maximum(%1257, %1250)  : (f32, f32) -> f32\n",
+      "    %1259 = llvm.fmul %1258, %1249  : f32\n",
+      "    %1260 = llvm.mlir.constant(0.280105054 : f32) : f32\n",
+      "    %1261 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1262 = llvm.mlir.constant(0.73282814 : f32) : f32\n",
+      "    %1263 = llvm.fmul %arg1, %1262  : f32\n",
+      "    %1264 = llvm.mlir.constant(-0.632541954 : f32) : f32\n",
+      "    %1265 = llvm.fmul %arg0, %1264  : f32\n",
+      "    %1266 = llvm.mlir.constant(-0.0431155674 : f32) : f32\n",
+      "    %1267 = llvm.fadd %1265, %1266  : f32\n",
+      "    %1268 = llvm.fadd %1263, %1267  : f32\n",
+      "    %1269 = llvm.intr.maximum(%1268, %1261)  : (f32, f32) -> f32\n",
+      "    %1270 = llvm.fmul %1269, %1260  : f32\n",
+      "    %1271 = llvm.mlir.constant(-0.28178072 : f32) : f32\n",
+      "    %1272 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1273 = llvm.mlir.constant(0.250564575 : f32) : f32\n",
+      "    %1274 = llvm.fmul %arg1, %1273  : f32\n",
+      "    %1275 = llvm.mlir.constant(-0.234713525 : f32) : f32\n",
+      "    %1276 = llvm.mlir.constant(-0.0761275962 : f32) : f32\n",
+      "    %1277 = llvm.fmul %arg0, %1276  : f32\n",
+      "    %1278 = llvm.fadd %1277, %1275  : f32\n",
+      "    %1279 = llvm.fadd %1274, %1278  : f32\n",
+      "    %1280 = llvm.intr.maximum(%1279, %1272)  : (f32, f32) -> f32\n",
+      "    %1281 = llvm.mlir.constant(-0.199137181 : f32) : f32\n",
+      "    %1282 = llvm.fmul %1280, %1281  : f32\n",
+      "    %1283 = llvm.fadd %1282, %1271  : f32\n",
+      "    %1284 = llvm.mlir.constant(-0.233263582 : f32) : f32\n",
+      "    %1285 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1286 = llvm.mlir.constant(-0.710041642 : f32) : f32\n",
+      "    %1287 = llvm.fmul %arg0, %1286  : f32\n",
+      "    %1288 = llvm.mlir.constant(-0.179663792 : f32) : f32\n",
+      "    %1289 = llvm.fadd %1287, %1288  : f32\n",
+      "    %1290 = llvm.mlir.constant(0.5115695 : f32) : f32\n",
+      "    %1291 = llvm.fmul %arg1, %1290  : f32\n",
+      "    %1292 = llvm.fadd %1289, %1291  : f32\n",
+      "    %1293 = llvm.intr.maximum(%1292, %1285)  : (f32, f32) -> f32\n",
+      "    %1294 = llvm.fmul %1293, %1284  : f32\n",
+      "    %1295 = llvm.fadd %1283, %1294  : f32\n",
+      "    %1296 = llvm.fadd %1270, %1295  : f32\n",
+      "    %1297 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1298 = llvm.mlir.constant(-0.148220554 : f32) : f32\n",
+      "    %1299 = llvm.mlir.constant(-0.266904861 : f32) : f32\n",
+      "    %1300 = llvm.fmul %arg0, %1299  : f32\n",
+      "    %1301 = llvm.fadd %1300, %1298  : f32\n",
+      "    %1302 = llvm.mlir.constant(0.591641366 : f32) : f32\n",
+      "    %1303 = llvm.fmul %arg1, %1302  : f32\n",
+      "    %1304 = llvm.fadd %1301, %1303  : f32\n",
+      "    %1305 = llvm.intr.maximum(%1304, %1297)  : (f32, f32) -> f32\n",
+      "    %1306 = llvm.mlir.constant(-0.696963191 : f32) : f32\n",
+      "    %1307 = llvm.fmul %1305, %1306  : f32\n",
+      "    %1308 = llvm.fadd %1296, %1307  : f32\n",
+      "    %1309 = llvm.fadd %1259, %1308  : f32\n",
+      "    %1310 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1311 = llvm.mlir.constant(-1.00863016 : f32) : f32\n",
+      "    %1312 = llvm.fmul %arg1, %1311  : f32\n",
+      "    %1313 = llvm.mlir.constant(-1.543290e+00 : f32) : f32\n",
+      "    %1314 = llvm.mlir.constant(1.41260469 : f32) : f32\n",
+      "    %1315 = llvm.fmul %arg0, %1314  : f32\n",
+      "    %1316 = llvm.fadd %1315, %1313  : f32\n",
+      "    %1317 = llvm.fadd %1312, %1316  : f32\n",
+      "    %1318 = llvm.intr.maximum(%1317, %1310)  : (f32, f32) -> f32\n",
+      "    %1319 = llvm.mlir.constant(0.0986800938 : f32) : f32\n",
+      "    %1320 = llvm.fmul %1318, %1319  : f32\n",
+      "    %1321 = llvm.fadd %1309, %1320  : f32\n",
+      "    %1322 = llvm.fadd %1248, %1321  : f32\n",
+      "    %1323 = llvm.mlir.constant(0.630481421 : f32) : f32\n",
+      "    %1324 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1325 = llvm.mlir.constant(0.766540825 : f32) : f32\n",
+      "    %1326 = llvm.fmul %arg1, %1325  : f32\n",
+      "    %1327 = llvm.mlir.constant(-0.924045622 : f32) : f32\n",
+      "    %1328 = llvm.fmul %arg0, %1327  : f32\n",
+      "    %1329 = llvm.mlir.constant(-0.259199619 : f32) : f32\n",
+      "    %1330 = llvm.fadd %1328, %1329  : f32\n",
+      "    %1331 = llvm.fadd %1326, %1330  : f32\n",
+      "    %1332 = llvm.intr.maximum(%1331, %1324)  : (f32, f32) -> f32\n",
+      "    %1333 = llvm.fmul %1332, %1323  : f32\n",
+      "    %1334 = llvm.fadd %1322, %1333  : f32\n",
+      "    %1335 = llvm.fadd %1237, %1334  : f32\n",
+      "    %1336 = llvm.mlir.constant(0.207257509 : f32) : f32\n",
+      "    %1337 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1338 = llvm.mlir.constant(-0.57726413 : f32) : f32\n",
+      "    %1339 = llvm.fmul %arg1, %1338  : f32\n",
+      "    %1340 = llvm.mlir.constant(0.598408341 : f32) : f32\n",
+      "    %1341 = llvm.fmul %arg0, %1340  : f32\n",
+      "    %1342 = llvm.mlir.constant(-0.580251634 : f32) : f32\n",
+      "    %1343 = llvm.fadd %1341, %1342  : f32\n",
+      "    %1344 = llvm.fadd %1339, %1343  : f32\n",
+      "    %1345 = llvm.intr.maximum(%1344, %1337)  : (f32, f32) -> f32\n",
+      "    %1346 = llvm.fmul %1345, %1336  : f32\n",
+      "    %1347 = llvm.fadd %1335, %1346  : f32\n",
+      "    %1348 = llvm.fadd %1226, %1347  : f32\n",
+      "    %1349 = llvm.fadd %1215, %1348  : f32\n",
+      "    %1350 = llvm.mlir.constant(-0.672088801 : f32) : f32\n",
+      "    %1351 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1352 = llvm.mlir.constant(0.315162152 : f32) : f32\n",
+      "    %1353 = llvm.mlir.constant(0.600057721 : f32) : f32\n",
+      "    %1354 = llvm.fmul %arg0, %1353  : f32\n",
+      "    %1355 = llvm.fadd %1354, %1352  : f32\n",
+      "    %1356 = llvm.mlir.constant(-0.313983649 : f32) : f32\n",
+      "    %1357 = llvm.fmul %arg1, %1356  : f32\n",
+      "    %1358 = llvm.fadd %1355, %1357  : f32\n",
+      "    %1359 = llvm.intr.maximum(%1358, %1351)  : (f32, f32) -> f32\n",
+      "    %1360 = llvm.fmul %1359, %1350  : f32\n",
+      "    %1361 = llvm.fadd %1349, %1360  : f32\n",
+      "    %1362 = llvm.fadd %1204, %1361  : f32\n",
+      "    %1363 = llvm.mlir.constant(-0.0681781247 : f32) : f32\n",
+      "    %1364 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1365 = llvm.mlir.constant(-0.0821817442 : f32) : f32\n",
+      "    %1366 = llvm.fmul %arg1, %1365  : f32\n",
+      "    %1367 = llvm.mlir.constant(-0.732010245 : f32) : f32\n",
+      "    %1368 = llvm.mlir.constant(-0.354400456 : f32) : f32\n",
+      "    %1369 = llvm.fmul %arg0, %1368  : f32\n",
+      "    %1370 = llvm.fadd %1369, %1367  : f32\n",
+      "    %1371 = llvm.fadd %1366, %1370  : f32\n",
+      "    %1372 = llvm.intr.maximum(%1371, %1364)  : (f32, f32) -> f32\n",
+      "    %1373 = llvm.fmul %1372, %1363  : f32\n",
+      "    %1374 = llvm.fadd %1362, %1373  : f32\n",
+      "    %1375 = llvm.fadd %1193, %1374  : f32\n",
+      "    %1376 = llvm.intr.maximum(%1375, %1182)  : (f32, f32) -> f32\n",
+      "    %1377 = llvm.mlir.constant(-0.374153018 : f32) : f32\n",
+      "    %1378 = llvm.fmul %1376, %1377  : f32\n",
+      "    %1379 = llvm.mlir.constant(0.528086424 : f32) : f32\n",
+      "    %1380 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1381 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1382 = llvm.mlir.constant(-0.217542693 : f32) : f32\n",
+      "    %1383 = llvm.mlir.constant(0.876379132 : f32) : f32\n",
+      "    %1384 = llvm.fmul %arg0, %1383  : f32\n",
+      "    %1385 = llvm.fadd %1384, %1382  : f32\n",
+      "    %1386 = llvm.mlir.constant(0.950005471 : f32) : f32\n",
+      "    %1387 = llvm.fmul %arg1, %1386  : f32\n",
+      "    %1388 = llvm.fadd %1385, %1387  : f32\n",
+      "    %1389 = llvm.intr.maximum(%1388, %1381)  : (f32, f32) -> f32\n",
+      "    %1390 = llvm.mlir.constant(0.122482195 : f32) : f32\n",
+      "    %1391 = llvm.fmul %1389, %1390  : f32\n",
+      "    %1392 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1393 = llvm.mlir.constant(-0.0821817442 : f32) : f32\n",
+      "    %1394 = llvm.fmul %arg1, %1393  : f32\n",
+      "    %1395 = llvm.mlir.constant(-0.732010245 : f32) : f32\n",
+      "    %1396 = llvm.mlir.constant(-0.354400456 : f32) : f32\n",
+      "    %1397 = llvm.fmul %arg0, %1396  : f32\n",
+      "    %1398 = llvm.fadd %1397, %1395  : f32\n",
+      "    %1399 = llvm.fadd %1394, %1398  : f32\n",
+      "    %1400 = llvm.intr.maximum(%1399, %1392)  : (f32, f32) -> f32\n",
+      "    %1401 = llvm.mlir.constant(-0.589337826 : f32) : f32\n",
+      "    %1402 = llvm.fmul %1400, %1401  : f32\n",
+      "    %1403 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1404 = llvm.mlir.constant(-0.57726413 : f32) : f32\n",
+      "    %1405 = llvm.fmul %arg1, %1404  : f32\n",
+      "    %1406 = llvm.mlir.constant(0.598408341 : f32) : f32\n",
+      "    %1407 = llvm.fmul %arg0, %1406  : f32\n",
+      "    %1408 = llvm.mlir.constant(-0.580251634 : f32) : f32\n",
+      "    %1409 = llvm.fadd %1407, %1408  : f32\n",
+      "    %1410 = llvm.fadd %1405, %1409  : f32\n",
+      "    %1411 = llvm.intr.maximum(%1410, %1403)  : (f32, f32) -> f32\n",
+      "    %1412 = llvm.mlir.constant(0.184484467 : f32) : f32\n",
+      "    %1413 = llvm.fmul %1411, %1412  : f32\n",
+      "    %1414 = llvm.mlir.constant(-0.135850221 : f32) : f32\n",
+      "    %1415 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1416 = llvm.mlir.constant(-0.771490633 : f32) : f32\n",
+      "    %1417 = llvm.fmul %arg1, %1416  : f32\n",
+      "    %1418 = llvm.mlir.constant(0.114797138 : f32) : f32\n",
+      "    %1419 = llvm.mlir.constant(-0.56365943 : f32) : f32\n",
+      "    %1420 = llvm.fmul %arg0, %1419  : f32\n",
+      "    %1421 = llvm.fadd %1420, %1418  : f32\n",
+      "    %1422 = llvm.fadd %1417, %1421  : f32\n",
+      "    %1423 = llvm.intr.maximum(%1422, %1415)  : (f32, f32) -> f32\n",
+      "    %1424 = llvm.fmul %1423, %1414  : f32\n",
+      "    %1425 = llvm.mlir.constant(0.699985682 : f32) : f32\n",
+      "    %1426 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1427 = llvm.mlir.constant(-1.00863016 : f32) : f32\n",
+      "    %1428 = llvm.fmul %arg1, %1427  : f32\n",
+      "    %1429 = llvm.mlir.constant(-1.543290e+00 : f32) : f32\n",
+      "    %1430 = llvm.mlir.constant(1.41260469 : f32) : f32\n",
+      "    %1431 = llvm.fmul %arg0, %1430  : f32\n",
+      "    %1432 = llvm.fadd %1431, %1429  : f32\n",
+      "    %1433 = llvm.fadd %1428, %1432  : f32\n",
+      "    %1434 = llvm.intr.maximum(%1433, %1426)  : (f32, f32) -> f32\n",
+      "    %1435 = llvm.fmul %1434, %1425  : f32\n",
+      "    %1436 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1437 = llvm.mlir.constant(-0.710041642 : f32) : f32\n",
+      "    %1438 = llvm.fmul %arg0, %1437  : f32\n",
+      "    %1439 = llvm.mlir.constant(-0.179663792 : f32) : f32\n",
+      "    %1440 = llvm.fadd %1438, %1439  : f32\n",
+      "    %1441 = llvm.mlir.constant(0.5115695 : f32) : f32\n",
+      "    %1442 = llvm.fmul %arg1, %1441  : f32\n",
+      "    %1443 = llvm.fadd %1440, %1442  : f32\n",
+      "    %1444 = llvm.intr.maximum(%1443, %1436)  : (f32, f32) -> f32\n",
+      "    %1445 = llvm.mlir.constant(-0.671048581 : f32) : f32\n",
+      "    %1446 = llvm.fmul %1444, %1445  : f32\n",
+      "    %1447 = llvm.mlir.constant(-0.23150371 : f32) : f32\n",
+      "    %1448 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1449 = llvm.mlir.constant(0.250564575 : f32) : f32\n",
+      "    %1450 = llvm.fmul %arg1, %1449  : f32\n",
+      "    %1451 = llvm.mlir.constant(-0.234713525 : f32) : f32\n",
+      "    %1452 = llvm.mlir.constant(-0.0761275962 : f32) : f32\n",
+      "    %1453 = llvm.fmul %arg0, %1452  : f32\n",
+      "    %1454 = llvm.fadd %1453, %1451  : f32\n",
+      "    %1455 = llvm.fadd %1450, %1454  : f32\n",
+      "    %1456 = llvm.intr.maximum(%1455, %1448)  : (f32, f32) -> f32\n",
+      "    %1457 = llvm.mlir.constant(-0.850440502 : f32) : f32\n",
+      "    %1458 = llvm.fmul %1456, %1457  : f32\n",
+      "    %1459 = llvm.fadd %1458, %1447  : f32\n",
+      "    %1460 = llvm.fadd %1446, %1459  : f32\n",
+      "    %1461 = llvm.mlir.constant(0.581202447 : f32) : f32\n",
+      "    %1462 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1463 = llvm.mlir.constant(0.73282814 : f32) : f32\n",
+      "    %1464 = llvm.fmul %arg1, %1463  : f32\n",
+      "    %1465 = llvm.mlir.constant(-0.632541954 : f32) : f32\n",
+      "    %1466 = llvm.fmul %arg0, %1465  : f32\n",
+      "    %1467 = llvm.mlir.constant(-0.0431155674 : f32) : f32\n",
+      "    %1468 = llvm.fadd %1466, %1467  : f32\n",
+      "    %1469 = llvm.fadd %1464, %1468  : f32\n",
+      "    %1470 = llvm.intr.maximum(%1469, %1462)  : (f32, f32) -> f32\n",
+      "    %1471 = llvm.fmul %1470, %1461  : f32\n",
+      "    %1472 = llvm.fadd %1460, %1471  : f32\n",
+      "    %1473 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1474 = llvm.mlir.constant(-0.148220554 : f32) : f32\n",
+      "    %1475 = llvm.mlir.constant(-0.266904861 : f32) : f32\n",
+      "    %1476 = llvm.fmul %arg0, %1475  : f32\n",
+      "    %1477 = llvm.fadd %1476, %1474  : f32\n",
+      "    %1478 = llvm.mlir.constant(0.591641366 : f32) : f32\n",
+      "    %1479 = llvm.fmul %arg1, %1478  : f32\n",
+      "    %1480 = llvm.fadd %1477, %1479  : f32\n",
+      "    %1481 = llvm.intr.maximum(%1480, %1473)  : (f32, f32) -> f32\n",
+      "    %1482 = llvm.mlir.constant(-0.666851401 : f32) : f32\n",
+      "    %1483 = llvm.fmul %1481, %1482  : f32\n",
+      "    %1484 = llvm.fadd %1472, %1483  : f32\n",
+      "    %1485 = llvm.mlir.constant(1.05570841 : f32) : f32\n",
+      "    %1486 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1487 = llvm.mlir.constant(-0.732560634 : f32) : f32\n",
+      "    %1488 = llvm.mlir.constant(0.659632384 : f32) : f32\n",
+      "    %1489 = llvm.fmul %arg0, %1488  : f32\n",
+      "    %1490 = llvm.fadd %1489, %1487  : f32\n",
+      "    %1491 = llvm.mlir.constant(-0.124262765 : f32) : f32\n",
+      "    %1492 = llvm.fmul %arg1, %1491  : f32\n",
+      "    %1493 = llvm.fadd %1490, %1492  : f32\n",
+      "    %1494 = llvm.intr.maximum(%1493, %1486)  : (f32, f32) -> f32\n",
+      "    %1495 = llvm.fmul %1494, %1485  : f32\n",
+      "    %1496 = llvm.fadd %1484, %1495  : f32\n",
+      "    %1497 = llvm.fadd %1435, %1496  : f32\n",
+      "    %1498 = llvm.mlir.constant(5.787050e-01 : f32) : f32\n",
+      "    %1499 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1500 = llvm.mlir.constant(9.201580e-01 : f32) : f32\n",
+      "    %1501 = llvm.fmul %arg0, %1500  : f32\n",
+      "    %1502 = llvm.mlir.constant(-0.444333524 : f32) : f32\n",
+      "    %1503 = llvm.fadd %1501, %1502  : f32\n",
+      "    %1504 = llvm.mlir.constant(0.859033763 : f32) : f32\n",
+      "    %1505 = llvm.fmul %arg1, %1504  : f32\n",
+      "    %1506 = llvm.fadd %1503, %1505  : f32\n",
+      "    %1507 = llvm.intr.maximum(%1506, %1499)  : (f32, f32) -> f32\n",
+      "    %1508 = llvm.fmul %1507, %1498  : f32\n",
+      "    %1509 = llvm.fadd %1497, %1508  : f32\n",
+      "    %1510 = llvm.mlir.constant(0.0478195623 : f32) : f32\n",
+      "    %1511 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1512 = llvm.mlir.constant(0.766540825 : f32) : f32\n",
+      "    %1513 = llvm.fmul %arg1, %1512  : f32\n",
+      "    %1514 = llvm.mlir.constant(-0.924045622 : f32) : f32\n",
+      "    %1515 = llvm.fmul %arg0, %1514  : f32\n",
+      "    %1516 = llvm.mlir.constant(-0.259199619 : f32) : f32\n",
+      "    %1517 = llvm.fadd %1515, %1516  : f32\n",
+      "    %1518 = llvm.fadd %1513, %1517  : f32\n",
+      "    %1519 = llvm.intr.maximum(%1518, %1511)  : (f32, f32) -> f32\n",
+      "    %1520 = llvm.fmul %1519, %1510  : f32\n",
+      "    %1521 = llvm.fadd %1509, %1520  : f32\n",
+      "    %1522 = llvm.fadd %1424, %1521  : f32\n",
+      "    %1523 = llvm.fadd %1413, %1522  : f32\n",
+      "    %1524 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1525 = llvm.mlir.constant(0.49928996 : f32) : f32\n",
+      "    %1526 = llvm.fmul %arg1, %1525  : f32\n",
+      "    %1527 = llvm.mlir.constant(-0.283014119 : f32) : f32\n",
+      "    %1528 = llvm.fmul %arg0, %1527  : f32\n",
+      "    %1529 = llvm.mlir.constant(0.0311395917 : f32) : f32\n",
+      "    %1530 = llvm.fadd %1528, %1529  : f32\n",
+      "    %1531 = llvm.fadd %1526, %1530  : f32\n",
+      "    %1532 = llvm.intr.maximum(%1531, %1524)  : (f32, f32) -> f32\n",
+      "    %1533 = llvm.mlir.constant(0.695252538 : f32) : f32\n",
+      "    %1534 = llvm.fmul %1532, %1533  : f32\n",
+      "    %1535 = llvm.fadd %1523, %1534  : f32\n",
+      "    %1536 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1537 = llvm.mlir.constant(0.58700037 : f32) : f32\n",
+      "    %1538 = llvm.fmul %arg1, %1537  : f32\n",
+      "    %1539 = llvm.mlir.constant(-0.0791633725 : f32) : f32\n",
+      "    %1540 = llvm.fmul %arg0, %1539  : f32\n",
+      "    %1541 = llvm.mlir.constant(-0.478744268 : f32) : f32\n",
+      "    %1542 = llvm.fadd %1540, %1541  : f32\n",
+      "    %1543 = llvm.fadd %1538, %1542  : f32\n",
+      "    %1544 = llvm.intr.maximum(%1543, %1536)  : (f32, f32) -> f32\n",
+      "    %1545 = llvm.mlir.constant(0.891454697 : f32) : f32\n",
+      "    %1546 = llvm.fmul %1544, %1545  : f32\n",
+      "    %1547 = llvm.fadd %1535, %1546  : f32\n",
+      "    %1548 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1549 = llvm.mlir.constant(0.315162152 : f32) : f32\n",
+      "    %1550 = llvm.mlir.constant(0.600057721 : f32) : f32\n",
+      "    %1551 = llvm.fmul %arg0, %1550  : f32\n",
+      "    %1552 = llvm.fadd %1551, %1549  : f32\n",
+      "    %1553 = llvm.mlir.constant(-0.313983649 : f32) : f32\n",
+      "    %1554 = llvm.fmul %arg1, %1553  : f32\n",
+      "    %1555 = llvm.fadd %1552, %1554  : f32\n",
+      "    %1556 = llvm.intr.maximum(%1555, %1548)  : (f32, f32) -> f32\n",
+      "    %1557 = llvm.mlir.constant(-0.322570443 : f32) : f32\n",
+      "    %1558 = llvm.fmul %1556, %1557  : f32\n",
+      "    %1559 = llvm.fadd %1547, %1558  : f32\n",
+      "    %1560 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1561 = llvm.mlir.constant(-0.169446096 : f32) : f32\n",
+      "    %1562 = llvm.mlir.constant(-0.215495735 : f32) : f32\n",
+      "    %1563 = llvm.fmul %arg0, %1562  : f32\n",
+      "    %1564 = llvm.fadd %1563, %1561  : f32\n",
+      "    %1565 = llvm.mlir.constant(0.985414206 : f32) : f32\n",
+      "    %1566 = llvm.fmul %arg1, %1565  : f32\n",
+      "    %1567 = llvm.fadd %1564, %1566  : f32\n",
+      "    %1568 = llvm.intr.maximum(%1567, %1560)  : (f32, f32) -> f32\n",
+      "    %1569 = llvm.mlir.constant(0.359131068 : f32) : f32\n",
+      "    %1570 = llvm.fmul %1568, %1569  : f32\n",
+      "    %1571 = llvm.fadd %1559, %1570  : f32\n",
+      "    %1572 = llvm.fadd %1402, %1571  : f32\n",
+      "    %1573 = llvm.fadd %1391, %1572  : f32\n",
+      "    %1574 = llvm.intr.maximum(%1573, %1380)  : (f32, f32) -> f32\n",
+      "    %1575 = llvm.fmul %1574, %1379  : f32\n",
+      "    %1576 = llvm.mlir.constant(-1.12636733 : f32) : f32\n",
+      "    %1577 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1578 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1579 = llvm.mlir.constant(-0.0821817442 : f32) : f32\n",
+      "    %1580 = llvm.fmul %arg1, %1579  : f32\n",
+      "    %1581 = llvm.mlir.constant(-0.732010245 : f32) : f32\n",
+      "    %1582 = llvm.mlir.constant(-0.354400456 : f32) : f32\n",
+      "    %1583 = llvm.fmul %arg0, %1582  : f32\n",
+      "    %1584 = llvm.fadd %1583, %1581  : f32\n",
+      "    %1585 = llvm.fadd %1580, %1584  : f32\n",
+      "    %1586 = llvm.intr.maximum(%1585, %1578)  : (f32, f32) -> f32\n",
+      "    %1587 = llvm.mlir.constant(-0.159962162 : f32) : f32\n",
+      "    %1588 = llvm.fmul %1586, %1587  : f32\n",
+      "    %1589 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1590 = llvm.mlir.constant(0.315162152 : f32) : f32\n",
+      "    %1591 = llvm.mlir.constant(0.600057721 : f32) : f32\n",
+      "    %1592 = llvm.fmul %arg0, %1591  : f32\n",
+      "    %1593 = llvm.fadd %1592, %1590  : f32\n",
+      "    %1594 = llvm.mlir.constant(-0.313983649 : f32) : f32\n",
+      "    %1595 = llvm.fmul %arg1, %1594  : f32\n",
+      "    %1596 = llvm.fadd %1593, %1595  : f32\n",
+      "    %1597 = llvm.intr.maximum(%1596, %1589)  : (f32, f32) -> f32\n",
+      "    %1598 = llvm.mlir.constant(-0.669221818 : f32) : f32\n",
+      "    %1599 = llvm.fmul %1597, %1598  : f32\n",
+      "    %1600 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1601 = llvm.mlir.constant(0.58700037 : f32) : f32\n",
+      "    %1602 = llvm.fmul %arg1, %1601  : f32\n",
+      "    %1603 = llvm.mlir.constant(-0.0791633725 : f32) : f32\n",
+      "    %1604 = llvm.fmul %arg0, %1603  : f32\n",
+      "    %1605 = llvm.mlir.constant(-0.478744268 : f32) : f32\n",
+      "    %1606 = llvm.fadd %1604, %1605  : f32\n",
+      "    %1607 = llvm.fadd %1602, %1606  : f32\n",
+      "    %1608 = llvm.intr.maximum(%1607, %1600)  : (f32, f32) -> f32\n",
+      "    %1609 = llvm.mlir.constant(0.597520947 : f32) : f32\n",
+      "    %1610 = llvm.fmul %1608, %1609  : f32\n",
+      "    %1611 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1612 = llvm.mlir.constant(0.49928996 : f32) : f32\n",
+      "    %1613 = llvm.fmul %arg1, %1612  : f32\n",
+      "    %1614 = llvm.mlir.constant(-0.283014119 : f32) : f32\n",
+      "    %1615 = llvm.fmul %arg0, %1614  : f32\n",
+      "    %1616 = llvm.mlir.constant(0.0311395917 : f32) : f32\n",
+      "    %1617 = llvm.fadd %1615, %1616  : f32\n",
+      "    %1618 = llvm.fadd %1613, %1617  : f32\n",
+      "    %1619 = llvm.intr.maximum(%1618, %1611)  : (f32, f32) -> f32\n",
+      "    %1620 = llvm.mlir.constant(0.423614085 : f32) : f32\n",
+      "    %1621 = llvm.fmul %1619, %1620  : f32\n",
+      "    %1622 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1623 = llvm.mlir.constant(-0.57726413 : f32) : f32\n",
+      "    %1624 = llvm.fmul %arg1, %1623  : f32\n",
+      "    %1625 = llvm.mlir.constant(0.598408341 : f32) : f32\n",
+      "    %1626 = llvm.fmul %arg0, %1625  : f32\n",
+      "    %1627 = llvm.mlir.constant(-0.580251634 : f32) : f32\n",
+      "    %1628 = llvm.fadd %1626, %1627  : f32\n",
+      "    %1629 = llvm.fadd %1624, %1628  : f32\n",
+      "    %1630 = llvm.intr.maximum(%1629, %1622)  : (f32, f32) -> f32\n",
+      "    %1631 = llvm.mlir.constant(-0.085840106 : f32) : f32\n",
+      "    %1632 = llvm.fmul %1630, %1631  : f32\n",
+      "    %1633 = llvm.mlir.constant(0.566285789 : f32) : f32\n",
+      "    %1634 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1635 = llvm.mlir.constant(-0.771490633 : f32) : f32\n",
+      "    %1636 = llvm.fmul %arg1, %1635  : f32\n",
+      "    %1637 = llvm.mlir.constant(0.114797138 : f32) : f32\n",
+      "    %1638 = llvm.mlir.constant(-0.56365943 : f32) : f32\n",
+      "    %1639 = llvm.fmul %arg0, %1638  : f32\n",
+      "    %1640 = llvm.fadd %1639, %1637  : f32\n",
+      "    %1641 = llvm.fadd %1636, %1640  : f32\n",
+      "    %1642 = llvm.intr.maximum(%1641, %1634)  : (f32, f32) -> f32\n",
+      "    %1643 = llvm.fmul %1642, %1633  : f32\n",
+      "    %1644 = llvm.mlir.constant(-0.577172399 : f32) : f32\n",
+      "    %1645 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1646 = llvm.mlir.constant(-1.00863016 : f32) : f32\n",
+      "    %1647 = llvm.fmul %arg1, %1646  : f32\n",
+      "    %1648 = llvm.mlir.constant(-1.543290e+00 : f32) : f32\n",
+      "    %1649 = llvm.mlir.constant(1.41260469 : f32) : f32\n",
+      "    %1650 = llvm.fmul %arg0, %1649  : f32\n",
+      "    %1651 = llvm.fadd %1650, %1648  : f32\n",
+      "    %1652 = llvm.fadd %1647, %1651  : f32\n",
+      "    %1653 = llvm.intr.maximum(%1652, %1645)  : (f32, f32) -> f32\n",
+      "    %1654 = llvm.fmul %1653, %1644  : f32\n",
+      "    %1655 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1656 = llvm.mlir.constant(-0.148220554 : f32) : f32\n",
+      "    %1657 = llvm.mlir.constant(-0.266904861 : f32) : f32\n",
+      "    %1658 = llvm.fmul %arg0, %1657  : f32\n",
+      "    %1659 = llvm.fadd %1658, %1656  : f32\n",
+      "    %1660 = llvm.mlir.constant(0.591641366 : f32) : f32\n",
+      "    %1661 = llvm.fmul %arg1, %1660  : f32\n",
+      "    %1662 = llvm.fadd %1659, %1661  : f32\n",
+      "    %1663 = llvm.intr.maximum(%1662, %1655)  : (f32, f32) -> f32\n",
+      "    %1664 = llvm.mlir.constant(0.693156182 : f32) : f32\n",
+      "    %1665 = llvm.fmul %1663, %1664  : f32\n",
+      "    %1666 = llvm.mlir.constant(-0.268363059 : f32) : f32\n",
+      "    %1667 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1668 = llvm.mlir.constant(0.73282814 : f32) : f32\n",
+      "    %1669 = llvm.fmul %arg1, %1668  : f32\n",
+      "    %1670 = llvm.mlir.constant(-0.632541954 : f32) : f32\n",
+      "    %1671 = llvm.fmul %arg0, %1670  : f32\n",
+      "    %1672 = llvm.mlir.constant(-0.0431155674 : f32) : f32\n",
+      "    %1673 = llvm.fadd %1671, %1672  : f32\n",
+      "    %1674 = llvm.fadd %1669, %1673  : f32\n",
+      "    %1675 = llvm.intr.maximum(%1674, %1667)  : (f32, f32) -> f32\n",
+      "    %1676 = llvm.fmul %1675, %1666  : f32\n",
+      "    %1677 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1678 = llvm.mlir.constant(0.250564575 : f32) : f32\n",
+      "    %1679 = llvm.fmul %arg1, %1678  : f32\n",
+      "    %1680 = llvm.mlir.constant(-0.234713525 : f32) : f32\n",
+      "    %1681 = llvm.mlir.constant(-0.0761275962 : f32) : f32\n",
+      "    %1682 = llvm.fmul %arg0, %1681  : f32\n",
+      "    %1683 = llvm.fadd %1682, %1680  : f32\n",
+      "    %1684 = llvm.fadd %1679, %1683  : f32\n",
+      "    %1685 = llvm.intr.maximum(%1684, %1677)  : (f32, f32) -> f32\n",
+      "    %1686 = llvm.mlir.constant(0.772116899 : f32) : f32\n",
+      "    %1687 = llvm.fmul %1685, %1686  : f32\n",
+      "    %1688 = llvm.mlir.constant(-0.309050083 : f32) : f32\n",
+      "    %1689 = llvm.fadd %1687, %1688  : f32\n",
+      "    %1690 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1691 = llvm.mlir.constant(-0.710041642 : f32) : f32\n",
+      "    %1692 = llvm.fmul %arg0, %1691  : f32\n",
+      "    %1693 = llvm.mlir.constant(-0.179663792 : f32) : f32\n",
+      "    %1694 = llvm.fadd %1692, %1693  : f32\n",
+      "    %1695 = llvm.mlir.constant(0.5115695 : f32) : f32\n",
+      "    %1696 = llvm.fmul %arg1, %1695  : f32\n",
+      "    %1697 = llvm.fadd %1694, %1696  : f32\n",
+      "    %1698 = llvm.intr.maximum(%1697, %1690)  : (f32, f32) -> f32\n",
+      "    %1699 = llvm.mlir.constant(0.567388058 : f32) : f32\n",
+      "    %1700 = llvm.fmul %1698, %1699  : f32\n",
+      "    %1701 = llvm.fadd %1689, %1700  : f32\n",
+      "    %1702 = llvm.fadd %1676, %1701  : f32\n",
+      "    %1703 = llvm.fadd %1665, %1702  : f32\n",
+      "    %1704 = llvm.mlir.constant(-0.105467163 : f32) : f32\n",
+      "    %1705 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1706 = llvm.mlir.constant(-0.732560634 : f32) : f32\n",
+      "    %1707 = llvm.mlir.constant(0.659632384 : f32) : f32\n",
+      "    %1708 = llvm.fmul %arg0, %1707  : f32\n",
+      "    %1709 = llvm.fadd %1708, %1706  : f32\n",
+      "    %1710 = llvm.mlir.constant(-0.124262765 : f32) : f32\n",
+      "    %1711 = llvm.fmul %arg1, %1710  : f32\n",
+      "    %1712 = llvm.fadd %1709, %1711  : f32\n",
+      "    %1713 = llvm.intr.maximum(%1712, %1705)  : (f32, f32) -> f32\n",
+      "    %1714 = llvm.fmul %1713, %1704  : f32\n",
+      "    %1715 = llvm.fadd %1703, %1714  : f32\n",
+      "    %1716 = llvm.fadd %1654, %1715  : f32\n",
+      "    %1717 = llvm.mlir.constant(0.765844702 : f32) : f32\n",
+      "    %1718 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1719 = llvm.mlir.constant(9.201580e-01 : f32) : f32\n",
+      "    %1720 = llvm.fmul %arg0, %1719  : f32\n",
+      "    %1721 = llvm.mlir.constant(-0.444333524 : f32) : f32\n",
+      "    %1722 = llvm.fadd %1720, %1721  : f32\n",
+      "    %1723 = llvm.mlir.constant(0.859033763 : f32) : f32\n",
+      "    %1724 = llvm.fmul %arg1, %1723  : f32\n",
+      "    %1725 = llvm.fadd %1722, %1724  : f32\n",
+      "    %1726 = llvm.intr.maximum(%1725, %1718)  : (f32, f32) -> f32\n",
+      "    %1727 = llvm.fmul %1726, %1717  : f32\n",
+      "    %1728 = llvm.fadd %1716, %1727  : f32\n",
+      "    %1729 = llvm.mlir.constant(0.246308625 : f32) : f32\n",
+      "    %1730 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1731 = llvm.mlir.constant(0.766540825 : f32) : f32\n",
+      "    %1732 = llvm.fmul %arg1, %1731  : f32\n",
+      "    %1733 = llvm.mlir.constant(-0.924045622 : f32) : f32\n",
+      "    %1734 = llvm.fmul %arg0, %1733  : f32\n",
+      "    %1735 = llvm.mlir.constant(-0.259199619 : f32) : f32\n",
+      "    %1736 = llvm.fadd %1734, %1735  : f32\n",
+      "    %1737 = llvm.fadd %1732, %1736  : f32\n",
+      "    %1738 = llvm.intr.maximum(%1737, %1730)  : (f32, f32) -> f32\n",
+      "    %1739 = llvm.fmul %1738, %1729  : f32\n",
+      "    %1740 = llvm.fadd %1728, %1739  : f32\n",
+      "    %1741 = llvm.fadd %1643, %1740  : f32\n",
+      "    %1742 = llvm.fadd %1632, %1741  : f32\n",
+      "    %1743 = llvm.fadd %1621, %1742  : f32\n",
+      "    %1744 = llvm.fadd %1610, %1743  : f32\n",
+      "    %1745 = llvm.fadd %1599, %1744  : f32\n",
+      "    %1746 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1747 = llvm.mlir.constant(-0.169446096 : f32) : f32\n",
+      "    %1748 = llvm.mlir.constant(-0.215495735 : f32) : f32\n",
+      "    %1749 = llvm.fmul %arg0, %1748  : f32\n",
+      "    %1750 = llvm.fadd %1749, %1747  : f32\n",
+      "    %1751 = llvm.mlir.constant(0.985414206 : f32) : f32\n",
+      "    %1752 = llvm.fmul %arg1, %1751  : f32\n",
+      "    %1753 = llvm.fadd %1750, %1752  : f32\n",
+      "    %1754 = llvm.intr.maximum(%1753, %1746)  : (f32, f32) -> f32\n",
+      "    %1755 = llvm.mlir.constant(1.12235129 : f32) : f32\n",
+      "    %1756 = llvm.fmul %1754, %1755  : f32\n",
+      "    %1757 = llvm.fadd %1745, %1756  : f32\n",
+      "    %1758 = llvm.fadd %1588, %1757  : f32\n",
+      "    %1759 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1760 = llvm.mlir.constant(-0.217542693 : f32) : f32\n",
+      "    %1761 = llvm.mlir.constant(0.876379132 : f32) : f32\n",
+      "    %1762 = llvm.fmul %arg0, %1761  : f32\n",
+      "    %1763 = llvm.fadd %1762, %1760  : f32\n",
+      "    %1764 = llvm.mlir.constant(0.950005471 : f32) : f32\n",
+      "    %1765 = llvm.fmul %arg1, %1764  : f32\n",
+      "    %1766 = llvm.fadd %1763, %1765  : f32\n",
+      "    %1767 = llvm.intr.maximum(%1766, %1759)  : (f32, f32) -> f32\n",
+      "    %1768 = llvm.mlir.constant(0.193981022 : f32) : f32\n",
+      "    %1769 = llvm.fmul %1767, %1768  : f32\n",
+      "    %1770 = llvm.fadd %1758, %1769  : f32\n",
+      "    %1771 = llvm.intr.maximum(%1770, %1577)  : (f32, f32) -> f32\n",
+      "    %1772 = llvm.fmul %1771, %1576  : f32\n",
+      "    %1773 = llvm.mlir.constant(2.562200e-01 : f32) : f32\n",
+      "    %1774 = llvm.mlir.constant(0.639304816 : f32) : f32\n",
+      "    %1775 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1776 = llvm.mlir.constant(-0.178967342 : f32) : f32\n",
+      "    %1777 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1778 = llvm.mlir.constant(-0.0821817442 : f32) : f32\n",
+      "    %1779 = llvm.fmul %arg1, %1778  : f32\n",
+      "    %1780 = llvm.mlir.constant(-0.732010245 : f32) : f32\n",
+      "    %1781 = llvm.mlir.constant(-0.354400456 : f32) : f32\n",
+      "    %1782 = llvm.fmul %arg0, %1781  : f32\n",
+      "    %1783 = llvm.fadd %1782, %1780  : f32\n",
+      "    %1784 = llvm.fadd %1779, %1783  : f32\n",
+      "    %1785 = llvm.intr.maximum(%1784, %1777)  : (f32, f32) -> f32\n",
+      "    %1786 = llvm.fmul %1785, %1776  : f32\n",
+      "    %1787 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1788 = llvm.mlir.constant(0.315162152 : f32) : f32\n",
+      "    %1789 = llvm.mlir.constant(0.600057721 : f32) : f32\n",
+      "    %1790 = llvm.fmul %arg0, %1789  : f32\n",
+      "    %1791 = llvm.fadd %1790, %1788  : f32\n",
+      "    %1792 = llvm.mlir.constant(-0.313983649 : f32) : f32\n",
+      "    %1793 = llvm.fmul %arg1, %1792  : f32\n",
+      "    %1794 = llvm.fadd %1791, %1793  : f32\n",
+      "    %1795 = llvm.intr.maximum(%1794, %1787)  : (f32, f32) -> f32\n",
+      "    %1796 = llvm.mlir.constant(0.122364961 : f32) : f32\n",
+      "    %1797 = llvm.fmul %1795, %1796  : f32\n",
+      "    %1798 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1799 = llvm.mlir.constant(0.49928996 : f32) : f32\n",
+      "    %1800 = llvm.fmul %arg1, %1799  : f32\n",
+      "    %1801 = llvm.mlir.constant(-0.283014119 : f32) : f32\n",
+      "    %1802 = llvm.fmul %arg0, %1801  : f32\n",
+      "    %1803 = llvm.mlir.constant(0.0311395917 : f32) : f32\n",
+      "    %1804 = llvm.fadd %1802, %1803  : f32\n",
+      "    %1805 = llvm.fadd %1800, %1804  : f32\n",
+      "    %1806 = llvm.intr.maximum(%1805, %1798)  : (f32, f32) -> f32\n",
+      "    %1807 = llvm.mlir.constant(0.214180484 : f32) : f32\n",
+      "    %1808 = llvm.fmul %1806, %1807  : f32\n",
+      "    %1809 = llvm.mlir.constant(0.302633196 : f32) : f32\n",
+      "    %1810 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1811 = llvm.mlir.constant(-0.57726413 : f32) : f32\n",
+      "    %1812 = llvm.fmul %arg1, %1811  : f32\n",
+      "    %1813 = llvm.mlir.constant(0.598408341 : f32) : f32\n",
+      "    %1814 = llvm.fmul %arg0, %1813  : f32\n",
+      "    %1815 = llvm.mlir.constant(-0.580251634 : f32) : f32\n",
+      "    %1816 = llvm.fadd %1814, %1815  : f32\n",
+      "    %1817 = llvm.fadd %1812, %1816  : f32\n",
+      "    %1818 = llvm.intr.maximum(%1817, %1810)  : (f32, f32) -> f32\n",
+      "    %1819 = llvm.fmul %1818, %1809  : f32\n",
+      "    %1820 = llvm.mlir.constant(0.525793195 : f32) : f32\n",
+      "    %1821 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1822 = llvm.mlir.constant(-0.732560634 : f32) : f32\n",
+      "    %1823 = llvm.mlir.constant(0.659632384 : f32) : f32\n",
+      "    %1824 = llvm.fmul %arg0, %1823  : f32\n",
+      "    %1825 = llvm.fadd %1824, %1822  : f32\n",
+      "    %1826 = llvm.mlir.constant(-0.124262765 : f32) : f32\n",
+      "    %1827 = llvm.fmul %arg1, %1826  : f32\n",
+      "    %1828 = llvm.fadd %1825, %1827  : f32\n",
+      "    %1829 = llvm.intr.maximum(%1828, %1821)  : (f32, f32) -> f32\n",
+      "    %1830 = llvm.fmul %1829, %1820  : f32\n",
+      "    %1831 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1832 = llvm.mlir.constant(-0.148220554 : f32) : f32\n",
+      "    %1833 = llvm.mlir.constant(-0.266904861 : f32) : f32\n",
+      "    %1834 = llvm.fmul %arg0, %1833  : f32\n",
+      "    %1835 = llvm.fadd %1834, %1832  : f32\n",
+      "    %1836 = llvm.mlir.constant(0.591641366 : f32) : f32\n",
+      "    %1837 = llvm.fmul %arg1, %1836  : f32\n",
+      "    %1838 = llvm.fadd %1835, %1837  : f32\n",
+      "    %1839 = llvm.intr.maximum(%1838, %1831)  : (f32, f32) -> f32\n",
+      "    %1840 = llvm.mlir.constant(-0.883046507 : f32) : f32\n",
+      "    %1841 = llvm.fmul %1839, %1840  : f32\n",
+      "    %1842 = llvm.mlir.constant(-0.588571489 : f32) : f32\n",
+      "    %1843 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1844 = llvm.mlir.constant(0.73282814 : f32) : f32\n",
+      "    %1845 = llvm.fmul %arg1, %1844  : f32\n",
+      "    %1846 = llvm.mlir.constant(-0.632541954 : f32) : f32\n",
+      "    %1847 = llvm.fmul %arg0, %1846  : f32\n",
+      "    %1848 = llvm.mlir.constant(-0.0431155674 : f32) : f32\n",
+      "    %1849 = llvm.fadd %1847, %1848  : f32\n",
+      "    %1850 = llvm.fadd %1845, %1849  : f32\n",
+      "    %1851 = llvm.intr.maximum(%1850, %1843)  : (f32, f32) -> f32\n",
+      "    %1852 = llvm.fmul %1851, %1842  : f32\n",
+      "    %1853 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1854 = llvm.mlir.constant(-0.710041642 : f32) : f32\n",
+      "    %1855 = llvm.fmul %arg0, %1854  : f32\n",
+      "    %1856 = llvm.mlir.constant(-0.179663792 : f32) : f32\n",
+      "    %1857 = llvm.fadd %1855, %1856  : f32\n",
+      "    %1858 = llvm.mlir.constant(0.5115695 : f32) : f32\n",
+      "    %1859 = llvm.fmul %arg1, %1858  : f32\n",
+      "    %1860 = llvm.fadd %1857, %1859  : f32\n",
+      "    %1861 = llvm.intr.maximum(%1860, %1853)  : (f32, f32) -> f32\n",
+      "    %1862 = llvm.mlir.constant(-0.41924867 : f32) : f32\n",
+      "    %1863 = llvm.fmul %1861, %1862  : f32\n",
+      "    %1864 = llvm.mlir.constant(0.0202288218 : f32) : f32\n",
+      "    %1865 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1866 = llvm.mlir.constant(0.250564575 : f32) : f32\n",
+      "    %1867 = llvm.fmul %arg1, %1866  : f32\n",
+      "    %1868 = llvm.mlir.constant(-0.234713525 : f32) : f32\n",
+      "    %1869 = llvm.mlir.constant(-0.0761275962 : f32) : f32\n",
+      "    %1870 = llvm.fmul %arg0, %1869  : f32\n",
+      "    %1871 = llvm.fadd %1870, %1868  : f32\n",
+      "    %1872 = llvm.fadd %1867, %1871  : f32\n",
+      "    %1873 = llvm.intr.maximum(%1872, %1865)  : (f32, f32) -> f32\n",
+      "    %1874 = llvm.mlir.constant(-0.00806666818 : f32) : f32\n",
+      "    %1875 = llvm.fmul %1873, %1874  : f32\n",
+      "    %1876 = llvm.fadd %1875, %1864  : f32\n",
+      "    %1877 = llvm.fadd %1863, %1876  : f32\n",
+      "    %1878 = llvm.fadd %1852, %1877  : f32\n",
+      "    %1879 = llvm.fadd %1841, %1878  : f32\n",
+      "    %1880 = llvm.fadd %1830, %1879  : f32\n",
+      "    %1881 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1882 = llvm.mlir.constant(-1.00863016 : f32) : f32\n",
+      "    %1883 = llvm.fmul %arg1, %1882  : f32\n",
+      "    %1884 = llvm.mlir.constant(-1.543290e+00 : f32) : f32\n",
+      "    %1885 = llvm.mlir.constant(1.41260469 : f32) : f32\n",
+      "    %1886 = llvm.fmul %arg0, %1885  : f32\n",
+      "    %1887 = llvm.fadd %1886, %1884  : f32\n",
+      "    %1888 = llvm.fadd %1883, %1887  : f32\n",
+      "    %1889 = llvm.intr.maximum(%1888, %1881)  : (f32, f32) -> f32\n",
+      "    %1890 = llvm.mlir.constant(0.44039011 : f32) : f32\n",
+      "    %1891 = llvm.fmul %1889, %1890  : f32\n",
+      "    %1892 = llvm.fadd %1880, %1891  : f32\n",
+      "    %1893 = llvm.mlir.constant(0.0764473453 : f32) : f32\n",
+      "    %1894 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1895 = llvm.mlir.constant(9.201580e-01 : f32) : f32\n",
+      "    %1896 = llvm.fmul %arg0, %1895  : f32\n",
+      "    %1897 = llvm.mlir.constant(-0.444333524 : f32) : f32\n",
+      "    %1898 = llvm.fadd %1896, %1897  : f32\n",
+      "    %1899 = llvm.mlir.constant(0.859033763 : f32) : f32\n",
+      "    %1900 = llvm.fmul %arg1, %1899  : f32\n",
+      "    %1901 = llvm.fadd %1898, %1900  : f32\n",
+      "    %1902 = llvm.intr.maximum(%1901, %1894)  : (f32, f32) -> f32\n",
+      "    %1903 = llvm.fmul %1902, %1893  : f32\n",
+      "    %1904 = llvm.fadd %1892, %1903  : f32\n",
+      "    %1905 = llvm.mlir.constant(-0.908632099 : f32) : f32\n",
+      "    %1906 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1907 = llvm.mlir.constant(0.766540825 : f32) : f32\n",
+      "    %1908 = llvm.fmul %arg1, %1907  : f32\n",
+      "    %1909 = llvm.mlir.constant(-0.924045622 : f32) : f32\n",
+      "    %1910 = llvm.fmul %arg0, %1909  : f32\n",
+      "    %1911 = llvm.mlir.constant(-0.259199619 : f32) : f32\n",
+      "    %1912 = llvm.fadd %1910, %1911  : f32\n",
+      "    %1913 = llvm.fadd %1908, %1912  : f32\n",
+      "    %1914 = llvm.intr.maximum(%1913, %1906)  : (f32, f32) -> f32\n",
+      "    %1915 = llvm.fmul %1914, %1905  : f32\n",
+      "    %1916 = llvm.fadd %1904, %1915  : f32\n",
+      "    %1917 = llvm.mlir.constant(-0.142801449 : f32) : f32\n",
+      "    %1918 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1919 = llvm.mlir.constant(-0.771490633 : f32) : f32\n",
+      "    %1920 = llvm.fmul %arg1, %1919  : f32\n",
+      "    %1921 = llvm.mlir.constant(0.114797138 : f32) : f32\n",
+      "    %1922 = llvm.mlir.constant(-0.56365943 : f32) : f32\n",
+      "    %1923 = llvm.fmul %arg0, %1922  : f32\n",
+      "    %1924 = llvm.fadd %1923, %1921  : f32\n",
+      "    %1925 = llvm.fadd %1920, %1924  : f32\n",
+      "    %1926 = llvm.intr.maximum(%1925, %1918)  : (f32, f32) -> f32\n",
+      "    %1927 = llvm.fmul %1926, %1917  : f32\n",
+      "    %1928 = llvm.fadd %1916, %1927  : f32\n",
+      "    %1929 = llvm.fadd %1819, %1928  : f32\n",
+      "    %1930 = llvm.fadd %1808, %1929  : f32\n",
+      "    %1931 = llvm.mlir.constant(0.5244326 : f32) : f32\n",
+      "    %1932 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1933 = llvm.mlir.constant(0.58700037 : f32) : f32\n",
+      "    %1934 = llvm.fmul %arg1, %1933  : f32\n",
+      "    %1935 = llvm.mlir.constant(-0.0791633725 : f32) : f32\n",
+      "    %1936 = llvm.fmul %arg0, %1935  : f32\n",
+      "    %1937 = llvm.mlir.constant(-0.478744268 : f32) : f32\n",
+      "    %1938 = llvm.fadd %1936, %1937  : f32\n",
+      "    %1939 = llvm.fadd %1934, %1938  : f32\n",
+      "    %1940 = llvm.intr.maximum(%1939, %1932)  : (f32, f32) -> f32\n",
+      "    %1941 = llvm.fmul %1940, %1931  : f32\n",
+      "    %1942 = llvm.fadd %1930, %1941  : f32\n",
+      "    %1943 = llvm.fadd %1797, %1942  : f32\n",
+      "    %1944 = llvm.mlir.constant(-0.686027109 : f32) : f32\n",
+      "    %1945 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1946 = llvm.mlir.constant(-0.169446096 : f32) : f32\n",
+      "    %1947 = llvm.mlir.constant(-0.215495735 : f32) : f32\n",
+      "    %1948 = llvm.fmul %arg0, %1947  : f32\n",
+      "    %1949 = llvm.fadd %1948, %1946  : f32\n",
+      "    %1950 = llvm.mlir.constant(0.985414206 : f32) : f32\n",
+      "    %1951 = llvm.fmul %arg1, %1950  : f32\n",
+      "    %1952 = llvm.fadd %1949, %1951  : f32\n",
+      "    %1953 = llvm.intr.maximum(%1952, %1945)  : (f32, f32) -> f32\n",
+      "    %1954 = llvm.fmul %1953, %1944  : f32\n",
+      "    %1955 = llvm.fadd %1943, %1954  : f32\n",
+      "    %1956 = llvm.fadd %1786, %1955  : f32\n",
+      "    %1957 = llvm.mlir.constant(-0.154727042 : f32) : f32\n",
+      "    %1958 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1959 = llvm.mlir.constant(-0.217542693 : f32) : f32\n",
+      "    %1960 = llvm.mlir.constant(0.876379132 : f32) : f32\n",
+      "    %1961 = llvm.fmul %arg0, %1960  : f32\n",
+      "    %1962 = llvm.fadd %1961, %1959  : f32\n",
+      "    %1963 = llvm.mlir.constant(0.950005471 : f32) : f32\n",
+      "    %1964 = llvm.fmul %arg1, %1963  : f32\n",
+      "    %1965 = llvm.fadd %1962, %1964  : f32\n",
+      "    %1966 = llvm.intr.maximum(%1965, %1958)  : (f32, f32) -> f32\n",
+      "    %1967 = llvm.fmul %1966, %1957  : f32\n",
+      "    %1968 = llvm.fadd %1956, %1967  : f32\n",
+      "    %1969 = llvm.intr.maximum(%1968, %1775)  : (f32, f32) -> f32\n",
+      "    %1970 = llvm.fmul %1969, %1774  : f32\n",
+      "    %1971 = llvm.fadd %1970, %1773  : f32\n",
+      "    %1972 = llvm.fadd %1772, %1971  : f32\n",
+      "    %1973 = llvm.mlir.constant(0.668829619 : f32) : f32\n",
+      "    %1974 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1975 = llvm.mlir.constant(-0.730834424 : f32) : f32\n",
+      "    %1976 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1977 = llvm.mlir.constant(-0.217542693 : f32) : f32\n",
+      "    %1978 = llvm.mlir.constant(0.876379132 : f32) : f32\n",
+      "    %1979 = llvm.fmul %arg0, %1978  : f32\n",
+      "    %1980 = llvm.fadd %1979, %1977  : f32\n",
+      "    %1981 = llvm.mlir.constant(0.950005471 : f32) : f32\n",
+      "    %1982 = llvm.fmul %arg1, %1981  : f32\n",
+      "    %1983 = llvm.fadd %1980, %1982  : f32\n",
+      "    %1984 = llvm.intr.maximum(%1983, %1976)  : (f32, f32) -> f32\n",
+      "    %1985 = llvm.fmul %1984, %1975  : f32\n",
+      "    %1986 = llvm.mlir.constant(-0.596406459 : f32) : f32\n",
+      "    %1987 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1988 = llvm.mlir.constant(-0.0821817442 : f32) : f32\n",
+      "    %1989 = llvm.fmul %arg1, %1988  : f32\n",
+      "    %1990 = llvm.mlir.constant(-0.732010245 : f32) : f32\n",
+      "    %1991 = llvm.mlir.constant(-0.354400456 : f32) : f32\n",
+      "    %1992 = llvm.fmul %arg0, %1991  : f32\n",
+      "    %1993 = llvm.fadd %1992, %1990  : f32\n",
+      "    %1994 = llvm.fadd %1989, %1993  : f32\n",
+      "    %1995 = llvm.intr.maximum(%1994, %1987)  : (f32, f32) -> f32\n",
+      "    %1996 = llvm.fmul %1995, %1986  : f32\n",
+      "    %1997 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %1998 = llvm.mlir.constant(-0.771490633 : f32) : f32\n",
+      "    %1999 = llvm.fmul %arg1, %1998  : f32\n",
+      "    %2000 = llvm.mlir.constant(0.114797138 : f32) : f32\n",
+      "    %2001 = llvm.mlir.constant(-0.56365943 : f32) : f32\n",
+      "    %2002 = llvm.fmul %arg0, %2001  : f32\n",
+      "    %2003 = llvm.fadd %2002, %2000  : f32\n",
+      "    %2004 = llvm.fadd %1999, %2003  : f32\n",
+      "    %2005 = llvm.intr.maximum(%2004, %1997)  : (f32, f32) -> f32\n",
+      "    %2006 = llvm.mlir.constant(0.518218696 : f32) : f32\n",
+      "    %2007 = llvm.fmul %2005, %2006  : f32\n",
+      "    %2008 = llvm.mlir.constant(-0.0488987677 : f32) : f32\n",
+      "    %2009 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2010 = llvm.mlir.constant(0.766540825 : f32) : f32\n",
+      "    %2011 = llvm.fmul %arg1, %2010  : f32\n",
+      "    %2012 = llvm.mlir.constant(-0.924045622 : f32) : f32\n",
+      "    %2013 = llvm.fmul %arg0, %2012  : f32\n",
+      "    %2014 = llvm.mlir.constant(-0.259199619 : f32) : f32\n",
+      "    %2015 = llvm.fadd %2013, %2014  : f32\n",
+      "    %2016 = llvm.fadd %2011, %2015  : f32\n",
+      "    %2017 = llvm.intr.maximum(%2016, %2009)  : (f32, f32) -> f32\n",
+      "    %2018 = llvm.fmul %2017, %2008  : f32\n",
+      "    %2019 = llvm.mlir.constant(0.531328857 : f32) : f32\n",
+      "    %2020 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2021 = llvm.mlir.constant(9.201580e-01 : f32) : f32\n",
+      "    %2022 = llvm.fmul %arg0, %2021  : f32\n",
+      "    %2023 = llvm.mlir.constant(-0.444333524 : f32) : f32\n",
+      "    %2024 = llvm.fadd %2022, %2023  : f32\n",
+      "    %2025 = llvm.mlir.constant(0.859033763 : f32) : f32\n",
+      "    %2026 = llvm.fmul %arg1, %2025  : f32\n",
+      "    %2027 = llvm.fadd %2024, %2026  : f32\n",
+      "    %2028 = llvm.intr.maximum(%2027, %2020)  : (f32, f32) -> f32\n",
+      "    %2029 = llvm.fmul %2028, %2019  : f32\n",
+      "    %2030 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2031 = llvm.mlir.constant(-1.00863016 : f32) : f32\n",
+      "    %2032 = llvm.fmul %arg1, %2031  : f32\n",
+      "    %2033 = llvm.mlir.constant(-1.543290e+00 : f32) : f32\n",
+      "    %2034 = llvm.mlir.constant(1.41260469 : f32) : f32\n",
+      "    %2035 = llvm.fmul %arg0, %2034  : f32\n",
+      "    %2036 = llvm.fadd %2035, %2033  : f32\n",
+      "    %2037 = llvm.fadd %2032, %2036  : f32\n",
+      "    %2038 = llvm.intr.maximum(%2037, %2030)  : (f32, f32) -> f32\n",
+      "    %2039 = llvm.mlir.constant(0.975892126 : f32) : f32\n",
+      "    %2040 = llvm.fmul %2038, %2039  : f32\n",
+      "    %2041 = llvm.mlir.constant(-0.0010520746 : f32) : f32\n",
+      "    %2042 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2043 = llvm.mlir.constant(0.73282814 : f32) : f32\n",
+      "    %2044 = llvm.fmul %arg1, %2043  : f32\n",
+      "    %2045 = llvm.mlir.constant(-0.632541954 : f32) : f32\n",
+      "    %2046 = llvm.fmul %arg0, %2045  : f32\n",
+      "    %2047 = llvm.mlir.constant(-0.0431155674 : f32) : f32\n",
+      "    %2048 = llvm.fadd %2046, %2047  : f32\n",
+      "    %2049 = llvm.fadd %2044, %2048  : f32\n",
+      "    %2050 = llvm.intr.maximum(%2049, %2042)  : (f32, f32) -> f32\n",
+      "    %2051 = llvm.fmul %2050, %2041  : f32\n",
+      "    %2052 = llvm.mlir.constant(0.257732332 : f32) : f32\n",
+      "    %2053 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2054 = llvm.mlir.constant(0.250564575 : f32) : f32\n",
+      "    %2055 = llvm.fmul %arg1, %2054  : f32\n",
+      "    %2056 = llvm.mlir.constant(-0.234713525 : f32) : f32\n",
+      "    %2057 = llvm.mlir.constant(-0.0761275962 : f32) : f32\n",
+      "    %2058 = llvm.fmul %arg0, %2057  : f32\n",
+      "    %2059 = llvm.fadd %2058, %2056  : f32\n",
+      "    %2060 = llvm.fadd %2055, %2059  : f32\n",
+      "    %2061 = llvm.intr.maximum(%2060, %2053)  : (f32, f32) -> f32\n",
+      "    %2062 = llvm.mlir.constant(0.625605702 : f32) : f32\n",
+      "    %2063 = llvm.fmul %2061, %2062  : f32\n",
+      "    %2064 = llvm.fadd %2063, %2052  : f32\n",
+      "    %2065 = llvm.mlir.constant(-0.870545149 : f32) : f32\n",
+      "    %2066 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2067 = llvm.mlir.constant(-0.710041642 : f32) : f32\n",
+      "    %2068 = llvm.fmul %arg0, %2067  : f32\n",
+      "    %2069 = llvm.mlir.constant(-0.179663792 : f32) : f32\n",
+      "    %2070 = llvm.fadd %2068, %2069  : f32\n",
+      "    %2071 = llvm.mlir.constant(0.5115695 : f32) : f32\n",
+      "    %2072 = llvm.fmul %arg1, %2071  : f32\n",
+      "    %2073 = llvm.fadd %2070, %2072  : f32\n",
+      "    %2074 = llvm.intr.maximum(%2073, %2066)  : (f32, f32) -> f32\n",
+      "    %2075 = llvm.fmul %2074, %2065  : f32\n",
+      "    %2076 = llvm.fadd %2064, %2075  : f32\n",
+      "    %2077 = llvm.fadd %2051, %2076  : f32\n",
+      "    %2078 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2079 = llvm.mlir.constant(-0.148220554 : f32) : f32\n",
+      "    %2080 = llvm.mlir.constant(-0.266904861 : f32) : f32\n",
+      "    %2081 = llvm.fmul %arg0, %2080  : f32\n",
+      "    %2082 = llvm.fadd %2081, %2079  : f32\n",
+      "    %2083 = llvm.mlir.constant(0.591641366 : f32) : f32\n",
+      "    %2084 = llvm.fmul %arg1, %2083  : f32\n",
+      "    %2085 = llvm.fadd %2082, %2084  : f32\n",
+      "    %2086 = llvm.intr.maximum(%2085, %2078)  : (f32, f32) -> f32\n",
+      "    %2087 = llvm.mlir.constant(0.444635749 : f32) : f32\n",
+      "    %2088 = llvm.fmul %2086, %2087  : f32\n",
+      "    %2089 = llvm.fadd %2077, %2088  : f32\n",
+      "    %2090 = llvm.mlir.constant(0.401048869 : f32) : f32\n",
+      "    %2091 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2092 = llvm.mlir.constant(-0.732560634 : f32) : f32\n",
+      "    %2093 = llvm.mlir.constant(0.659632384 : f32) : f32\n",
+      "    %2094 = llvm.fmul %arg0, %2093  : f32\n",
+      "    %2095 = llvm.fadd %2094, %2092  : f32\n",
+      "    %2096 = llvm.mlir.constant(-0.124262765 : f32) : f32\n",
+      "    %2097 = llvm.fmul %arg1, %2096  : f32\n",
+      "    %2098 = llvm.fadd %2095, %2097  : f32\n",
+      "    %2099 = llvm.intr.maximum(%2098, %2091)  : (f32, f32) -> f32\n",
+      "    %2100 = llvm.fmul %2099, %2090  : f32\n",
+      "    %2101 = llvm.fadd %2089, %2100  : f32\n",
+      "    %2102 = llvm.fadd %2040, %2101  : f32\n",
+      "    %2103 = llvm.fadd %2029, %2102  : f32\n",
+      "    %2104 = llvm.fadd %2018, %2103  : f32\n",
+      "    %2105 = llvm.fadd %2007, %2104  : f32\n",
+      "    %2106 = llvm.mlir.constant(0.459850818 : f32) : f32\n",
+      "    %2107 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2108 = llvm.mlir.constant(-0.57726413 : f32) : f32\n",
+      "    %2109 = llvm.fmul %arg1, %2108  : f32\n",
+      "    %2110 = llvm.mlir.constant(0.598408341 : f32) : f32\n",
+      "    %2111 = llvm.fmul %arg0, %2110  : f32\n",
+      "    %2112 = llvm.mlir.constant(-0.580251634 : f32) : f32\n",
+      "    %2113 = llvm.fadd %2111, %2112  : f32\n",
+      "    %2114 = llvm.fadd %2109, %2113  : f32\n",
+      "    %2115 = llvm.intr.maximum(%2114, %2107)  : (f32, f32) -> f32\n",
+      "    %2116 = llvm.fmul %2115, %2106  : f32\n",
+      "    %2117 = llvm.fadd %2105, %2116  : f32\n",
+      "    %2118 = llvm.mlir.constant(-0.309546381 : f32) : f32\n",
+      "    %2119 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2120 = llvm.mlir.constant(0.49928996 : f32) : f32\n",
+      "    %2121 = llvm.fmul %arg1, %2120  : f32\n",
+      "    %2122 = llvm.mlir.constant(-0.283014119 : f32) : f32\n",
+      "    %2123 = llvm.fmul %arg0, %2122  : f32\n",
+      "    %2124 = llvm.mlir.constant(0.0311395917 : f32) : f32\n",
+      "    %2125 = llvm.fadd %2123, %2124  : f32\n",
+      "    %2126 = llvm.fadd %2121, %2125  : f32\n",
+      "    %2127 = llvm.intr.maximum(%2126, %2119)  : (f32, f32) -> f32\n",
+      "    %2128 = llvm.fmul %2127, %2118  : f32\n",
+      "    %2129 = llvm.fadd %2117, %2128  : f32\n",
+      "    %2130 = llvm.mlir.constant(0.300776184 : f32) : f32\n",
+      "    %2131 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2132 = llvm.mlir.constant(0.58700037 : f32) : f32\n",
+      "    %2133 = llvm.fmul %arg1, %2132  : f32\n",
+      "    %2134 = llvm.mlir.constant(-0.0791633725 : f32) : f32\n",
+      "    %2135 = llvm.fmul %arg0, %2134  : f32\n",
+      "    %2136 = llvm.mlir.constant(-0.478744268 : f32) : f32\n",
+      "    %2137 = llvm.fadd %2135, %2136  : f32\n",
+      "    %2138 = llvm.fadd %2133, %2137  : f32\n",
+      "    %2139 = llvm.intr.maximum(%2138, %2131)  : (f32, f32) -> f32\n",
+      "    %2140 = llvm.fmul %2139, %2130  : f32\n",
+      "    %2141 = llvm.fadd %2129, %2140  : f32\n",
+      "    %2142 = llvm.mlir.constant(0.0459807366 : f32) : f32\n",
+      "    %2143 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2144 = llvm.mlir.constant(0.315162152 : f32) : f32\n",
+      "    %2145 = llvm.mlir.constant(0.600057721 : f32) : f32\n",
+      "    %2146 = llvm.fmul %arg0, %2145  : f32\n",
+      "    %2147 = llvm.fadd %2146, %2144  : f32\n",
+      "    %2148 = llvm.mlir.constant(-0.313983649 : f32) : f32\n",
+      "    %2149 = llvm.fmul %arg1, %2148  : f32\n",
+      "    %2150 = llvm.fadd %2147, %2149  : f32\n",
+      "    %2151 = llvm.intr.maximum(%2150, %2143)  : (f32, f32) -> f32\n",
+      "    %2152 = llvm.fmul %2151, %2142  : f32\n",
+      "    %2153 = llvm.fadd %2141, %2152  : f32\n",
+      "    %2154 = llvm.mlir.constant(-0.53265518 : f32) : f32\n",
+      "    %2155 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2156 = llvm.mlir.constant(-0.169446096 : f32) : f32\n",
+      "    %2157 = llvm.mlir.constant(-0.215495735 : f32) : f32\n",
+      "    %2158 = llvm.fmul %arg0, %2157  : f32\n",
+      "    %2159 = llvm.fadd %2158, %2156  : f32\n",
+      "    %2160 = llvm.mlir.constant(0.985414206 : f32) : f32\n",
+      "    %2161 = llvm.fmul %arg1, %2160  : f32\n",
+      "    %2162 = llvm.fadd %2159, %2161  : f32\n",
+      "    %2163 = llvm.intr.maximum(%2162, %2155)  : (f32, f32) -> f32\n",
+      "    %2164 = llvm.fmul %2163, %2154  : f32\n",
+      "    %2165 = llvm.fadd %2153, %2164  : f32\n",
+      "    %2166 = llvm.fadd %1996, %2165  : f32\n",
+      "    %2167 = llvm.fadd %1985, %2166  : f32\n",
+      "    %2168 = llvm.intr.maximum(%2167, %1974)  : (f32, f32) -> f32\n",
+      "    %2169 = llvm.fmul %2168, %1973  : f32\n",
+      "    %2170 = llvm.fadd %1972, %2169  : f32\n",
+      "    %2171 = llvm.fadd %1575, %2170  : f32\n",
+      "    %2172 = llvm.mlir.constant(0.335885912 : f32) : f32\n",
+      "    %2173 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2174 = llvm.mlir.constant(0.359619111 : f32) : f32\n",
+      "    %2175 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2176 = llvm.mlir.constant(-0.217542693 : f32) : f32\n",
+      "    %2177 = llvm.mlir.constant(0.876379132 : f32) : f32\n",
+      "    %2178 = llvm.fmul %arg0, %2177  : f32\n",
+      "    %2179 = llvm.fadd %2178, %2176  : f32\n",
+      "    %2180 = llvm.mlir.constant(0.950005471 : f32) : f32\n",
+      "    %2181 = llvm.fmul %arg1, %2180  : f32\n",
+      "    %2182 = llvm.fadd %2179, %2181  : f32\n",
+      "    %2183 = llvm.intr.maximum(%2182, %2175)  : (f32, f32) -> f32\n",
+      "    %2184 = llvm.fmul %2183, %2174  : f32\n",
+      "    %2185 = llvm.mlir.constant(-3.036590e-02 : f32) : f32\n",
+      "    %2186 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2187 = llvm.mlir.constant(0.766540825 : f32) : f32\n",
+      "    %2188 = llvm.fmul %arg1, %2187  : f32\n",
+      "    %2189 = llvm.mlir.constant(-0.924045622 : f32) : f32\n",
+      "    %2190 = llvm.fmul %arg0, %2189  : f32\n",
+      "    %2191 = llvm.mlir.constant(-0.259199619 : f32) : f32\n",
+      "    %2192 = llvm.fadd %2190, %2191  : f32\n",
+      "    %2193 = llvm.fadd %2188, %2192  : f32\n",
+      "    %2194 = llvm.intr.maximum(%2193, %2186)  : (f32, f32) -> f32\n",
+      "    %2195 = llvm.fmul %2194, %2185  : f32\n",
+      "    %2196 = llvm.mlir.constant(-0.780613839 : f32) : f32\n",
+      "    %2197 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2198 = llvm.mlir.constant(9.201580e-01 : f32) : f32\n",
+      "    %2199 = llvm.fmul %arg0, %2198  : f32\n",
+      "    %2200 = llvm.mlir.constant(-0.444333524 : f32) : f32\n",
+      "    %2201 = llvm.fadd %2199, %2200  : f32\n",
+      "    %2202 = llvm.mlir.constant(0.859033763 : f32) : f32\n",
+      "    %2203 = llvm.fmul %arg1, %2202  : f32\n",
+      "    %2204 = llvm.fadd %2201, %2203  : f32\n",
+      "    %2205 = llvm.intr.maximum(%2204, %2197)  : (f32, f32) -> f32\n",
+      "    %2206 = llvm.fmul %2205, %2196  : f32\n",
+      "    %2207 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2208 = llvm.mlir.constant(-1.00863016 : f32) : f32\n",
+      "    %2209 = llvm.fmul %arg1, %2208  : f32\n",
+      "    %2210 = llvm.mlir.constant(-1.543290e+00 : f32) : f32\n",
+      "    %2211 = llvm.mlir.constant(1.41260469 : f32) : f32\n",
+      "    %2212 = llvm.fmul %arg0, %2211  : f32\n",
+      "    %2213 = llvm.fadd %2212, %2210  : f32\n",
+      "    %2214 = llvm.fadd %2209, %2213  : f32\n",
+      "    %2215 = llvm.intr.maximum(%2214, %2207)  : (f32, f32) -> f32\n",
+      "    %2216 = llvm.mlir.constant(0.471114248 : f32) : f32\n",
+      "    %2217 = llvm.fmul %2215, %2216  : f32\n",
+      "    %2218 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2219 = llvm.mlir.constant(-0.148220554 : f32) : f32\n",
+      "    %2220 = llvm.mlir.constant(-0.266904861 : f32) : f32\n",
+      "    %2221 = llvm.fmul %arg0, %2220  : f32\n",
+      "    %2222 = llvm.fadd %2221, %2219  : f32\n",
+      "    %2223 = llvm.mlir.constant(0.591641366 : f32) : f32\n",
+      "    %2224 = llvm.fmul %arg1, %2223  : f32\n",
+      "    %2225 = llvm.fadd %2222, %2224  : f32\n",
+      "    %2226 = llvm.intr.maximum(%2225, %2218)  : (f32, f32) -> f32\n",
+      "    %2227 = llvm.mlir.constant(0.319991469 : f32) : f32\n",
+      "    %2228 = llvm.fmul %2226, %2227  : f32\n",
+      "    %2229 = llvm.mlir.constant(-0.287262648 : f32) : f32\n",
+      "    %2230 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2231 = llvm.mlir.constant(0.73282814 : f32) : f32\n",
+      "    %2232 = llvm.fmul %arg1, %2231  : f32\n",
+      "    %2233 = llvm.mlir.constant(-0.632541954 : f32) : f32\n",
+      "    %2234 = llvm.fmul %arg0, %2233  : f32\n",
+      "    %2235 = llvm.mlir.constant(-0.0431155674 : f32) : f32\n",
+      "    %2236 = llvm.fadd %2234, %2235  : f32\n",
+      "    %2237 = llvm.fadd %2232, %2236  : f32\n",
+      "    %2238 = llvm.intr.maximum(%2237, %2230)  : (f32, f32) -> f32\n",
+      "    %2239 = llvm.fmul %2238, %2229  : f32\n",
+      "    %2240 = llvm.mlir.constant(-0.0978555381 : f32) : f32\n",
+      "    %2241 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2242 = llvm.mlir.constant(0.250564575 : f32) : f32\n",
+      "    %2243 = llvm.fmul %arg1, %2242  : f32\n",
+      "    %2244 = llvm.mlir.constant(-0.234713525 : f32) : f32\n",
+      "    %2245 = llvm.mlir.constant(-0.0761275962 : f32) : f32\n",
+      "    %2246 = llvm.fmul %arg0, %2245  : f32\n",
+      "    %2247 = llvm.fadd %2246, %2244  : f32\n",
+      "    %2248 = llvm.fadd %2243, %2247  : f32\n",
+      "    %2249 = llvm.intr.maximum(%2248, %2241)  : (f32, f32) -> f32\n",
+      "    %2250 = llvm.mlir.constant(-0.261587203 : f32) : f32\n",
+      "    %2251 = llvm.fmul %2249, %2250  : f32\n",
+      "    %2252 = llvm.fadd %2251, %2240  : f32\n",
+      "    %2253 = llvm.mlir.constant(-0.823098242 : f32) : f32\n",
+      "    %2254 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2255 = llvm.mlir.constant(-0.710041642 : f32) : f32\n",
+      "    %2256 = llvm.fmul %arg0, %2255  : f32\n",
+      "    %2257 = llvm.mlir.constant(-0.179663792 : f32) : f32\n",
+      "    %2258 = llvm.fadd %2256, %2257  : f32\n",
+      "    %2259 = llvm.mlir.constant(0.5115695 : f32) : f32\n",
+      "    %2260 = llvm.fmul %arg1, %2259  : f32\n",
+      "    %2261 = llvm.fadd %2258, %2260  : f32\n",
+      "    %2262 = llvm.intr.maximum(%2261, %2254)  : (f32, f32) -> f32\n",
+      "    %2263 = llvm.fmul %2262, %2253  : f32\n",
+      "    %2264 = llvm.fadd %2252, %2263  : f32\n",
+      "    %2265 = llvm.fadd %2239, %2264  : f32\n",
+      "    %2266 = llvm.fadd %2228, %2265  : f32\n",
+      "    %2267 = llvm.mlir.constant(0.460389555 : f32) : f32\n",
+      "    %2268 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2269 = llvm.mlir.constant(-0.732560634 : f32) : f32\n",
+      "    %2270 = llvm.mlir.constant(0.659632384 : f32) : f32\n",
+      "    %2271 = llvm.fmul %arg0, %2270  : f32\n",
+      "    %2272 = llvm.fadd %2271, %2269  : f32\n",
+      "    %2273 = llvm.mlir.constant(-0.124262765 : f32) : f32\n",
+      "    %2274 = llvm.fmul %arg1, %2273  : f32\n",
+      "    %2275 = llvm.fadd %2272, %2274  : f32\n",
+      "    %2276 = llvm.intr.maximum(%2275, %2268)  : (f32, f32) -> f32\n",
+      "    %2277 = llvm.fmul %2276, %2267  : f32\n",
+      "    %2278 = llvm.fadd %2266, %2277  : f32\n",
+      "    %2279 = llvm.fadd %2217, %2278  : f32\n",
+      "    %2280 = llvm.fadd %2206, %2279  : f32\n",
+      "    %2281 = llvm.fadd %2195, %2280  : f32\n",
+      "    %2282 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2283 = llvm.mlir.constant(-0.771490633 : f32) : f32\n",
+      "    %2284 = llvm.fmul %arg1, %2283  : f32\n",
+      "    %2285 = llvm.mlir.constant(0.114797138 : f32) : f32\n",
+      "    %2286 = llvm.mlir.constant(-0.56365943 : f32) : f32\n",
+      "    %2287 = llvm.fmul %arg0, %2286  : f32\n",
+      "    %2288 = llvm.fadd %2287, %2285  : f32\n",
+      "    %2289 = llvm.fadd %2284, %2288  : f32\n",
+      "    %2290 = llvm.intr.maximum(%2289, %2282)  : (f32, f32) -> f32\n",
+      "    %2291 = llvm.mlir.constant(0.246853709 : f32) : f32\n",
+      "    %2292 = llvm.fmul %2290, %2291  : f32\n",
+      "    %2293 = llvm.fadd %2281, %2292  : f32\n",
+      "    %2294 = llvm.mlir.constant(0.0512480512 : f32) : f32\n",
+      "    %2295 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2296 = llvm.mlir.constant(-0.57726413 : f32) : f32\n",
+      "    %2297 = llvm.fmul %arg1, %2296  : f32\n",
+      "    %2298 = llvm.mlir.constant(0.598408341 : f32) : f32\n",
+      "    %2299 = llvm.fmul %arg0, %2298  : f32\n",
+      "    %2300 = llvm.mlir.constant(-0.580251634 : f32) : f32\n",
+      "    %2301 = llvm.fadd %2299, %2300  : f32\n",
+      "    %2302 = llvm.fadd %2297, %2301  : f32\n",
+      "    %2303 = llvm.intr.maximum(%2302, %2295)  : (f32, f32) -> f32\n",
+      "    %2304 = llvm.fmul %2303, %2294  : f32\n",
+      "    %2305 = llvm.fadd %2293, %2304  : f32\n",
+      "    %2306 = llvm.mlir.constant(-0.700860143 : f32) : f32\n",
+      "    %2307 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2308 = llvm.mlir.constant(0.49928996 : f32) : f32\n",
+      "    %2309 = llvm.fmul %arg1, %2308  : f32\n",
+      "    %2310 = llvm.mlir.constant(-0.283014119 : f32) : f32\n",
+      "    %2311 = llvm.fmul %arg0, %2310  : f32\n",
+      "    %2312 = llvm.mlir.constant(0.0311395917 : f32) : f32\n",
+      "    %2313 = llvm.fadd %2311, %2312  : f32\n",
+      "    %2314 = llvm.fadd %2309, %2313  : f32\n",
+      "    %2315 = llvm.intr.maximum(%2314, %2307)  : (f32, f32) -> f32\n",
+      "    %2316 = llvm.fmul %2315, %2306  : f32\n",
+      "    %2317 = llvm.fadd %2305, %2316  : f32\n",
+      "    %2318 = llvm.mlir.constant(0.505459845 : f32) : f32\n",
+      "    %2319 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2320 = llvm.mlir.constant(0.58700037 : f32) : f32\n",
+      "    %2321 = llvm.fmul %arg1, %2320  : f32\n",
+      "    %2322 = llvm.mlir.constant(-0.0791633725 : f32) : f32\n",
+      "    %2323 = llvm.fmul %arg0, %2322  : f32\n",
+      "    %2324 = llvm.mlir.constant(-0.478744268 : f32) : f32\n",
+      "    %2325 = llvm.fadd %2323, %2324  : f32\n",
+      "    %2326 = llvm.fadd %2321, %2325  : f32\n",
+      "    %2327 = llvm.intr.maximum(%2326, %2319)  : (f32, f32) -> f32\n",
+      "    %2328 = llvm.fmul %2327, %2318  : f32\n",
+      "    %2329 = llvm.fadd %2317, %2328  : f32\n",
+      "    %2330 = llvm.mlir.constant(0.456075549 : f32) : f32\n",
+      "    %2331 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2332 = llvm.mlir.constant(0.315162152 : f32) : f32\n",
+      "    %2333 = llvm.mlir.constant(0.600057721 : f32) : f32\n",
+      "    %2334 = llvm.fmul %arg0, %2333  : f32\n",
+      "    %2335 = llvm.fadd %2334, %2332  : f32\n",
+      "    %2336 = llvm.mlir.constant(-0.313983649 : f32) : f32\n",
+      "    %2337 = llvm.fmul %arg1, %2336  : f32\n",
+      "    %2338 = llvm.fadd %2335, %2337  : f32\n",
+      "    %2339 = llvm.intr.maximum(%2338, %2331)  : (f32, f32) -> f32\n",
+      "    %2340 = llvm.fmul %2339, %2330  : f32\n",
+      "    %2341 = llvm.fadd %2329, %2340  : f32\n",
+      "    %2342 = llvm.mlir.constant(-0.307049543 : f32) : f32\n",
+      "    %2343 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2344 = llvm.mlir.constant(-0.169446096 : f32) : f32\n",
+      "    %2345 = llvm.mlir.constant(-0.215495735 : f32) : f32\n",
+      "    %2346 = llvm.fmul %arg0, %2345  : f32\n",
+      "    %2347 = llvm.fadd %2346, %2344  : f32\n",
+      "    %2348 = llvm.mlir.constant(0.985414206 : f32) : f32\n",
+      "    %2349 = llvm.fmul %arg1, %2348  : f32\n",
+      "    %2350 = llvm.fadd %2347, %2349  : f32\n",
+      "    %2351 = llvm.intr.maximum(%2350, %2343)  : (f32, f32) -> f32\n",
+      "    %2352 = llvm.fmul %2351, %2342  : f32\n",
+      "    %2353 = llvm.fadd %2341, %2352  : f32\n",
+      "    %2354 = llvm.mlir.constant(-0.460197389 : f32) : f32\n",
+      "    %2355 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2356 = llvm.mlir.constant(-0.0821817442 : f32) : f32\n",
+      "    %2357 = llvm.fmul %arg1, %2356  : f32\n",
+      "    %2358 = llvm.mlir.constant(-0.732010245 : f32) : f32\n",
+      "    %2359 = llvm.mlir.constant(-0.354400456 : f32) : f32\n",
+      "    %2360 = llvm.fmul %arg0, %2359  : f32\n",
+      "    %2361 = llvm.fadd %2360, %2358  : f32\n",
+      "    %2362 = llvm.fadd %2357, %2361  : f32\n",
+      "    %2363 = llvm.intr.maximum(%2362, %2355)  : (f32, f32) -> f32\n",
+      "    %2364 = llvm.fmul %2363, %2354  : f32\n",
+      "    %2365 = llvm.fadd %2353, %2364  : f32\n",
+      "    %2366 = llvm.fadd %2184, %2365  : f32\n",
+      "    %2367 = llvm.intr.maximum(%2366, %2173)  : (f32, f32) -> f32\n",
+      "    %2368 = llvm.fmul %2367, %2172  : f32\n",
+      "    %2369 = llvm.fadd %2171, %2368  : f32\n",
+      "    %2370 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2371 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2372 = llvm.mlir.constant(-0.169446096 : f32) : f32\n",
+      "    %2373 = llvm.mlir.constant(-0.215495735 : f32) : f32\n",
+      "    %2374 = llvm.fmul %arg0, %2373  : f32\n",
+      "    %2375 = llvm.fadd %2374, %2372  : f32\n",
+      "    %2376 = llvm.mlir.constant(0.985414206 : f32) : f32\n",
+      "    %2377 = llvm.fmul %arg1, %2376  : f32\n",
+      "    %2378 = llvm.fadd %2375, %2377  : f32\n",
+      "    %2379 = llvm.intr.maximum(%2378, %2371)  : (f32, f32) -> f32\n",
+      "    %2380 = llvm.mlir.constant(0.691210032 : f32) : f32\n",
+      "    %2381 = llvm.fmul %2379, %2380  : f32\n",
+      "    %2382 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2383 = llvm.mlir.constant(0.315162152 : f32) : f32\n",
+      "    %2384 = llvm.mlir.constant(0.600057721 : f32) : f32\n",
+      "    %2385 = llvm.fmul %arg0, %2384  : f32\n",
+      "    %2386 = llvm.fadd %2385, %2383  : f32\n",
+      "    %2387 = llvm.mlir.constant(-0.313983649 : f32) : f32\n",
+      "    %2388 = llvm.fmul %arg1, %2387  : f32\n",
+      "    %2389 = llvm.fadd %2386, %2388  : f32\n",
+      "    %2390 = llvm.intr.maximum(%2389, %2382)  : (f32, f32) -> f32\n",
+      "    %2391 = llvm.mlir.constant(0.548442841 : f32) : f32\n",
+      "    %2392 = llvm.fmul %2390, %2391  : f32\n",
+      "    %2393 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2394 = llvm.mlir.constant(0.58700037 : f32) : f32\n",
+      "    %2395 = llvm.fmul %arg1, %2394  : f32\n",
+      "    %2396 = llvm.mlir.constant(-0.0791633725 : f32) : f32\n",
+      "    %2397 = llvm.fmul %arg0, %2396  : f32\n",
+      "    %2398 = llvm.mlir.constant(-0.478744268 : f32) : f32\n",
+      "    %2399 = llvm.fadd %2397, %2398  : f32\n",
+      "    %2400 = llvm.fadd %2395, %2399  : f32\n",
+      "    %2401 = llvm.intr.maximum(%2400, %2393)  : (f32, f32) -> f32\n",
+      "    %2402 = llvm.mlir.constant(0.0827218666 : f32) : f32\n",
+      "    %2403 = llvm.fmul %2401, %2402  : f32\n",
+      "    %2404 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2405 = llvm.mlir.constant(0.49928996 : f32) : f32\n",
+      "    %2406 = llvm.fmul %arg1, %2405  : f32\n",
+      "    %2407 = llvm.mlir.constant(-0.283014119 : f32) : f32\n",
+      "    %2408 = llvm.fmul %arg0, %2407  : f32\n",
+      "    %2409 = llvm.mlir.constant(0.0311395917 : f32) : f32\n",
+      "    %2410 = llvm.fadd %2408, %2409  : f32\n",
+      "    %2411 = llvm.fadd %2406, %2410  : f32\n",
+      "    %2412 = llvm.intr.maximum(%2411, %2404)  : (f32, f32) -> f32\n",
+      "    %2413 = llvm.mlir.constant(0.866046488 : f32) : f32\n",
+      "    %2414 = llvm.fmul %2412, %2413  : f32\n",
+      "    %2415 = llvm.mlir.constant(0.270038962 : f32) : f32\n",
+      "    %2416 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2417 = llvm.mlir.constant(-0.771490633 : f32) : f32\n",
+      "    %2418 = llvm.fmul %arg1, %2417  : f32\n",
+      "    %2419 = llvm.mlir.constant(0.114797138 : f32) : f32\n",
+      "    %2420 = llvm.mlir.constant(-0.56365943 : f32) : f32\n",
+      "    %2421 = llvm.fmul %arg0, %2420  : f32\n",
+      "    %2422 = llvm.fadd %2421, %2419  : f32\n",
+      "    %2423 = llvm.fadd %2418, %2422  : f32\n",
+      "    %2424 = llvm.intr.maximum(%2423, %2416)  : (f32, f32) -> f32\n",
+      "    %2425 = llvm.fmul %2424, %2415  : f32\n",
+      "    %2426 = llvm.mlir.constant(-1.26353586 : f32) : f32\n",
+      "    %2427 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2428 = llvm.mlir.constant(9.201580e-01 : f32) : f32\n",
+      "    %2429 = llvm.fmul %arg0, %2428  : f32\n",
+      "    %2430 = llvm.mlir.constant(-0.444333524 : f32) : f32\n",
+      "    %2431 = llvm.fadd %2429, %2430  : f32\n",
+      "    %2432 = llvm.mlir.constant(0.859033763 : f32) : f32\n",
+      "    %2433 = llvm.fmul %arg1, %2432  : f32\n",
+      "    %2434 = llvm.fadd %2431, %2433  : f32\n",
+      "    %2435 = llvm.intr.maximum(%2434, %2427)  : (f32, f32) -> f32\n",
+      "    %2436 = llvm.fmul %2435, %2426  : f32\n",
+      "    %2437 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2438 = llvm.mlir.constant(-0.148220554 : f32) : f32\n",
+      "    %2439 = llvm.mlir.constant(-0.266904861 : f32) : f32\n",
+      "    %2440 = llvm.fmul %arg0, %2439  : f32\n",
+      "    %2441 = llvm.fadd %2440, %2438  : f32\n",
+      "    %2442 = llvm.mlir.constant(0.591641366 : f32) : f32\n",
+      "    %2443 = llvm.fmul %arg1, %2442  : f32\n",
+      "    %2444 = llvm.fadd %2441, %2443  : f32\n",
+      "    %2445 = llvm.intr.maximum(%2444, %2437)  : (f32, f32) -> f32\n",
+      "    %2446 = llvm.mlir.constant(-0.0635462329 : f32) : f32\n",
+      "    %2447 = llvm.fmul %2445, %2446  : f32\n",
+      "    %2448 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2449 = llvm.mlir.constant(0.250564575 : f32) : f32\n",
+      "    %2450 = llvm.fmul %arg1, %2449  : f32\n",
+      "    %2451 = llvm.mlir.constant(-0.234713525 : f32) : f32\n",
+      "    %2452 = llvm.mlir.constant(-0.0761275962 : f32) : f32\n",
+      "    %2453 = llvm.fmul %arg0, %2452  : f32\n",
+      "    %2454 = llvm.fadd %2453, %2451  : f32\n",
+      "    %2455 = llvm.fadd %2450, %2454  : f32\n",
+      "    %2456 = llvm.intr.maximum(%2455, %2448)  : (f32, f32) -> f32\n",
+      "    %2457 = llvm.mlir.constant(0.244729027 : f32) : f32\n",
+      "    %2458 = llvm.fmul %2456, %2457  : f32\n",
+      "    %2459 = llvm.mlir.constant(0.780372142 : f32) : f32\n",
+      "    %2460 = llvm.fadd %2458, %2459  : f32\n",
+      "    %2461 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2462 = llvm.mlir.constant(-0.710041642 : f32) : f32\n",
+      "    %2463 = llvm.fmul %arg0, %2462  : f32\n",
+      "    %2464 = llvm.mlir.constant(-0.179663792 : f32) : f32\n",
+      "    %2465 = llvm.fadd %2463, %2464  : f32\n",
+      "    %2466 = llvm.mlir.constant(0.5115695 : f32) : f32\n",
+      "    %2467 = llvm.fmul %arg1, %2466  : f32\n",
+      "    %2468 = llvm.fadd %2465, %2467  : f32\n",
+      "    %2469 = llvm.intr.maximum(%2468, %2461)  : (f32, f32) -> f32\n",
+      "    %2470 = llvm.mlir.constant(-0.224412367 : f32) : f32\n",
+      "    %2471 = llvm.fmul %2469, %2470  : f32\n",
+      "    %2472 = llvm.fadd %2460, %2471  : f32\n",
+      "    %2473 = llvm.mlir.constant(-0.640570402 : f32) : f32\n",
+      "    %2474 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2475 = llvm.mlir.constant(0.73282814 : f32) : f32\n",
+      "    %2476 = llvm.fmul %arg1, %2475  : f32\n",
+      "    %2477 = llvm.mlir.constant(-0.632541954 : f32) : f32\n",
+      "    %2478 = llvm.fmul %arg0, %2477  : f32\n",
+      "    %2479 = llvm.mlir.constant(-0.0431155674 : f32) : f32\n",
+      "    %2480 = llvm.fadd %2478, %2479  : f32\n",
+      "    %2481 = llvm.fadd %2476, %2480  : f32\n",
+      "    %2482 = llvm.intr.maximum(%2481, %2474)  : (f32, f32) -> f32\n",
+      "    %2483 = llvm.fmul %2482, %2473  : f32\n",
+      "    %2484 = llvm.fadd %2472, %2483  : f32\n",
+      "    %2485 = llvm.fadd %2447, %2484  : f32\n",
+      "    %2486 = llvm.mlir.constant(0.386913508 : f32) : f32\n",
+      "    %2487 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2488 = llvm.mlir.constant(-0.732560634 : f32) : f32\n",
+      "    %2489 = llvm.mlir.constant(0.659632384 : f32) : f32\n",
+      "    %2490 = llvm.fmul %arg0, %2489  : f32\n",
+      "    %2491 = llvm.fadd %2490, %2488  : f32\n",
+      "    %2492 = llvm.mlir.constant(-0.124262765 : f32) : f32\n",
+      "    %2493 = llvm.fmul %arg1, %2492  : f32\n",
+      "    %2494 = llvm.fadd %2491, %2493  : f32\n",
+      "    %2495 = llvm.intr.maximum(%2494, %2487)  : (f32, f32) -> f32\n",
+      "    %2496 = llvm.fmul %2495, %2486  : f32\n",
+      "    %2497 = llvm.fadd %2485, %2496  : f32\n",
+      "    %2498 = llvm.mlir.constant(-0.359200835 : f32) : f32\n",
+      "    %2499 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2500 = llvm.mlir.constant(-1.00863016 : f32) : f32\n",
+      "    %2501 = llvm.fmul %arg1, %2500  : f32\n",
+      "    %2502 = llvm.mlir.constant(-1.543290e+00 : f32) : f32\n",
+      "    %2503 = llvm.mlir.constant(1.41260469 : f32) : f32\n",
+      "    %2504 = llvm.fmul %arg0, %2503  : f32\n",
+      "    %2505 = llvm.fadd %2504, %2502  : f32\n",
+      "    %2506 = llvm.fadd %2501, %2505  : f32\n",
+      "    %2507 = llvm.intr.maximum(%2506, %2499)  : (f32, f32) -> f32\n",
+      "    %2508 = llvm.fmul %2507, %2498  : f32\n",
+      "    %2509 = llvm.fadd %2497, %2508  : f32\n",
+      "    %2510 = llvm.fadd %2436, %2509  : f32\n",
+      "    %2511 = llvm.mlir.constant(0.142222181 : f32) : f32\n",
+      "    %2512 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2513 = llvm.mlir.constant(0.766540825 : f32) : f32\n",
+      "    %2514 = llvm.fmul %arg1, %2513  : f32\n",
+      "    %2515 = llvm.mlir.constant(-0.924045622 : f32) : f32\n",
+      "    %2516 = llvm.fmul %arg0, %2515  : f32\n",
+      "    %2517 = llvm.mlir.constant(-0.259199619 : f32) : f32\n",
+      "    %2518 = llvm.fadd %2516, %2517  : f32\n",
+      "    %2519 = llvm.fadd %2514, %2518  : f32\n",
+      "    %2520 = llvm.intr.maximum(%2519, %2512)  : (f32, f32) -> f32\n",
+      "    %2521 = llvm.fmul %2520, %2511  : f32\n",
+      "    %2522 = llvm.fadd %2510, %2521  : f32\n",
+      "    %2523 = llvm.fadd %2425, %2522  : f32\n",
+      "    %2524 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2525 = llvm.mlir.constant(-0.57726413 : f32) : f32\n",
+      "    %2526 = llvm.fmul %arg1, %2525  : f32\n",
+      "    %2527 = llvm.mlir.constant(0.598408341 : f32) : f32\n",
+      "    %2528 = llvm.fmul %arg0, %2527  : f32\n",
+      "    %2529 = llvm.mlir.constant(-0.580251634 : f32) : f32\n",
+      "    %2530 = llvm.fadd %2528, %2529  : f32\n",
+      "    %2531 = llvm.fadd %2526, %2530  : f32\n",
+      "    %2532 = llvm.intr.maximum(%2531, %2524)  : (f32, f32) -> f32\n",
+      "    %2533 = llvm.mlir.constant(-0.367917359 : f32) : f32\n",
+      "    %2534 = llvm.fmul %2532, %2533  : f32\n",
+      "    %2535 = llvm.fadd %2523, %2534  : f32\n",
+      "    %2536 = llvm.fadd %2414, %2535  : f32\n",
+      "    %2537 = llvm.fadd %2403, %2536  : f32\n",
+      "    %2538 = llvm.fadd %2392, %2537  : f32\n",
+      "    %2539 = llvm.fadd %2381, %2538  : f32\n",
+      "    %2540 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2541 = llvm.mlir.constant(-0.0821817442 : f32) : f32\n",
+      "    %2542 = llvm.fmul %arg1, %2541  : f32\n",
+      "    %2543 = llvm.mlir.constant(-0.732010245 : f32) : f32\n",
+      "    %2544 = llvm.mlir.constant(-0.354400456 : f32) : f32\n",
+      "    %2545 = llvm.fmul %arg0, %2544  : f32\n",
+      "    %2546 = llvm.fadd %2545, %2543  : f32\n",
+      "    %2547 = llvm.fadd %2542, %2546  : f32\n",
+      "    %2548 = llvm.intr.maximum(%2547, %2540)  : (f32, f32) -> f32\n",
+      "    %2549 = llvm.mlir.constant(-0.543990493 : f32) : f32\n",
+      "    %2550 = llvm.fmul %2548, %2549  : f32\n",
+      "    %2551 = llvm.fadd %2539, %2550  : f32\n",
+      "    %2552 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2553 = llvm.mlir.constant(-0.217542693 : f32) : f32\n",
+      "    %2554 = llvm.mlir.constant(0.876379132 : f32) : f32\n",
+      "    %2555 = llvm.fmul %arg0, %2554  : f32\n",
+      "    %2556 = llvm.fadd %2555, %2553  : f32\n",
+      "    %2557 = llvm.mlir.constant(0.950005471 : f32) : f32\n",
+      "    %2558 = llvm.fmul %arg1, %2557  : f32\n",
+      "    %2559 = llvm.fadd %2556, %2558  : f32\n",
+      "    %2560 = llvm.intr.maximum(%2559, %2552)  : (f32, f32) -> f32\n",
+      "    %2561 = llvm.mlir.constant(-0.660584747 : f32) : f32\n",
+      "    %2562 = llvm.fmul %2560, %2561  : f32\n",
+      "    %2563 = llvm.fadd %2551, %2562  : f32\n",
+      "    %2564 = llvm.intr.maximum(%2563, %2370)  : (f32, f32) -> f32\n",
+      "    %2565 = llvm.mlir.constant(1.25225878 : f32) : f32\n",
+      "    %2566 = llvm.fmul %2564, %2565  : f32\n",
+      "    %2567 = llvm.fadd %2369, %2566  : f32\n",
+      "    %2568 = llvm.fadd %1378, %2567  : f32\n",
+      "    %2569 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2570 = llvm.mlir.constant(0.979715406 : f32) : f32\n",
+      "    %2571 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2572 = llvm.mlir.constant(-0.217542693 : f32) : f32\n",
+      "    %2573 = llvm.mlir.constant(0.876379132 : f32) : f32\n",
+      "    %2574 = llvm.fmul %arg0, %2573  : f32\n",
+      "    %2575 = llvm.fadd %2574, %2572  : f32\n",
+      "    %2576 = llvm.mlir.constant(0.950005471 : f32) : f32\n",
+      "    %2577 = llvm.fmul %arg1, %2576  : f32\n",
+      "    %2578 = llvm.fadd %2575, %2577  : f32\n",
+      "    %2579 = llvm.intr.maximum(%2578, %2571)  : (f32, f32) -> f32\n",
+      "    %2580 = llvm.fmul %2579, %2570  : f32\n",
+      "    %2581 = llvm.mlir.constant(0.753859996 : f32) : f32\n",
+      "    %2582 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2583 = llvm.mlir.constant(0.58700037 : f32) : f32\n",
+      "    %2584 = llvm.fmul %arg1, %2583  : f32\n",
+      "    %2585 = llvm.mlir.constant(-0.0791633725 : f32) : f32\n",
+      "    %2586 = llvm.fmul %arg0, %2585  : f32\n",
+      "    %2587 = llvm.mlir.constant(-0.478744268 : f32) : f32\n",
+      "    %2588 = llvm.fadd %2586, %2587  : f32\n",
+      "    %2589 = llvm.fadd %2584, %2588  : f32\n",
+      "    %2590 = llvm.intr.maximum(%2589, %2582)  : (f32, f32) -> f32\n",
+      "    %2591 = llvm.fmul %2590, %2581  : f32\n",
+      "    %2592 = llvm.mlir.constant(-0.889114737 : f32) : f32\n",
+      "    %2593 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2594 = llvm.mlir.constant(0.766540825 : f32) : f32\n",
+      "    %2595 = llvm.fmul %arg1, %2594  : f32\n",
+      "    %2596 = llvm.mlir.constant(-0.924045622 : f32) : f32\n",
+      "    %2597 = llvm.fmul %arg0, %2596  : f32\n",
+      "    %2598 = llvm.mlir.constant(-0.259199619 : f32) : f32\n",
+      "    %2599 = llvm.fadd %2597, %2598  : f32\n",
+      "    %2600 = llvm.fadd %2595, %2599  : f32\n",
+      "    %2601 = llvm.intr.maximum(%2600, %2593)  : (f32, f32) -> f32\n",
+      "    %2602 = llvm.fmul %2601, %2592  : f32\n",
+      "    %2603 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2604 = llvm.mlir.constant(-1.00863016 : f32) : f32\n",
+      "    %2605 = llvm.fmul %arg1, %2604  : f32\n",
+      "    %2606 = llvm.mlir.constant(-1.543290e+00 : f32) : f32\n",
+      "    %2607 = llvm.mlir.constant(1.41260469 : f32) : f32\n",
+      "    %2608 = llvm.fmul %arg0, %2607  : f32\n",
+      "    %2609 = llvm.fadd %2608, %2606  : f32\n",
+      "    %2610 = llvm.fadd %2605, %2609  : f32\n",
+      "    %2611 = llvm.intr.maximum(%2610, %2603)  : (f32, f32) -> f32\n",
+      "    %2612 = llvm.mlir.constant(-1.06445384 : f32) : f32\n",
+      "    %2613 = llvm.fmul %2611, %2612  : f32\n",
+      "    %2614 = llvm.mlir.constant(-0.0182704665 : f32) : f32\n",
+      "    %2615 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2616 = llvm.mlir.constant(0.73282814 : f32) : f32\n",
+      "    %2617 = llvm.fmul %arg1, %2616  : f32\n",
+      "    %2618 = llvm.mlir.constant(-0.632541954 : f32) : f32\n",
+      "    %2619 = llvm.fmul %arg0, %2618  : f32\n",
+      "    %2620 = llvm.mlir.constant(-0.0431155674 : f32) : f32\n",
+      "    %2621 = llvm.fadd %2619, %2620  : f32\n",
+      "    %2622 = llvm.fadd %2617, %2621  : f32\n",
+      "    %2623 = llvm.intr.maximum(%2622, %2615)  : (f32, f32) -> f32\n",
+      "    %2624 = llvm.fmul %2623, %2614  : f32\n",
+      "    %2625 = llvm.mlir.constant(-0.049364958 : f32) : f32\n",
+      "    %2626 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2627 = llvm.mlir.constant(0.250564575 : f32) : f32\n",
+      "    %2628 = llvm.fmul %arg1, %2627  : f32\n",
+      "    %2629 = llvm.mlir.constant(-0.234713525 : f32) : f32\n",
+      "    %2630 = llvm.mlir.constant(-0.0761275962 : f32) : f32\n",
+      "    %2631 = llvm.fmul %arg0, %2630  : f32\n",
+      "    %2632 = llvm.fadd %2631, %2629  : f32\n",
+      "    %2633 = llvm.fadd %2628, %2632  : f32\n",
+      "    %2634 = llvm.intr.maximum(%2633, %2626)  : (f32, f32) -> f32\n",
+      "    %2635 = llvm.mlir.constant(-0.754470706 : f32) : f32\n",
+      "    %2636 = llvm.fmul %2634, %2635  : f32\n",
+      "    %2637 = llvm.fadd %2636, %2625  : f32\n",
+      "    %2638 = llvm.mlir.constant(0.699967682 : f32) : f32\n",
+      "    %2639 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2640 = llvm.mlir.constant(-0.710041642 : f32) : f32\n",
+      "    %2641 = llvm.fmul %arg0, %2640  : f32\n",
+      "    %2642 = llvm.mlir.constant(-0.179663792 : f32) : f32\n",
+      "    %2643 = llvm.fadd %2641, %2642  : f32\n",
+      "    %2644 = llvm.mlir.constant(0.5115695 : f32) : f32\n",
+      "    %2645 = llvm.fmul %arg1, %2644  : f32\n",
+      "    %2646 = llvm.fadd %2643, %2645  : f32\n",
+      "    %2647 = llvm.intr.maximum(%2646, %2639)  : (f32, f32) -> f32\n",
+      "    %2648 = llvm.fmul %2647, %2638  : f32\n",
+      "    %2649 = llvm.fadd %2637, %2648  : f32\n",
+      "    %2650 = llvm.fadd %2624, %2649  : f32\n",
+      "    %2651 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2652 = llvm.mlir.constant(-0.148220554 : f32) : f32\n",
+      "    %2653 = llvm.mlir.constant(-0.266904861 : f32) : f32\n",
+      "    %2654 = llvm.fmul %arg0, %2653  : f32\n",
+      "    %2655 = llvm.fadd %2654, %2652  : f32\n",
+      "    %2656 = llvm.mlir.constant(0.591641366 : f32) : f32\n",
+      "    %2657 = llvm.fmul %arg1, %2656  : f32\n",
+      "    %2658 = llvm.fadd %2655, %2657  : f32\n",
+      "    %2659 = llvm.intr.maximum(%2658, %2651)  : (f32, f32) -> f32\n",
+      "    %2660 = llvm.mlir.constant(-0.236047834 : f32) : f32\n",
+      "    %2661 = llvm.fmul %2659, %2660  : f32\n",
+      "    %2662 = llvm.fadd %2650, %2661  : f32\n",
+      "    %2663 = llvm.mlir.constant(0.0205109604 : f32) : f32\n",
+      "    %2664 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2665 = llvm.mlir.constant(-0.732560634 : f32) : f32\n",
+      "    %2666 = llvm.mlir.constant(0.659632384 : f32) : f32\n",
+      "    %2667 = llvm.fmul %arg0, %2666  : f32\n",
+      "    %2668 = llvm.fadd %2667, %2665  : f32\n",
+      "    %2669 = llvm.mlir.constant(-0.124262765 : f32) : f32\n",
+      "    %2670 = llvm.fmul %arg1, %2669  : f32\n",
+      "    %2671 = llvm.fadd %2668, %2670  : f32\n",
+      "    %2672 = llvm.intr.maximum(%2671, %2664)  : (f32, f32) -> f32\n",
+      "    %2673 = llvm.fmul %2672, %2663  : f32\n",
+      "    %2674 = llvm.fadd %2662, %2673  : f32\n",
+      "    %2675 = llvm.fadd %2613, %2674  : f32\n",
+      "    %2676 = llvm.mlir.constant(-0.421450615 : f32) : f32\n",
+      "    %2677 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2678 = llvm.mlir.constant(9.201580e-01 : f32) : f32\n",
+      "    %2679 = llvm.fmul %arg0, %2678  : f32\n",
+      "    %2680 = llvm.mlir.constant(-0.444333524 : f32) : f32\n",
+      "    %2681 = llvm.fadd %2679, %2680  : f32\n",
+      "    %2682 = llvm.mlir.constant(0.859033763 : f32) : f32\n",
+      "    %2683 = llvm.fmul %arg1, %2682  : f32\n",
+      "    %2684 = llvm.fadd %2681, %2683  : f32\n",
+      "    %2685 = llvm.intr.maximum(%2684, %2677)  : (f32, f32) -> f32\n",
+      "    %2686 = llvm.fmul %2685, %2676  : f32\n",
+      "    %2687 = llvm.fadd %2675, %2686  : f32\n",
+      "    %2688 = llvm.fadd %2602, %2687  : f32\n",
+      "    %2689 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2690 = llvm.mlir.constant(-0.771490633 : f32) : f32\n",
+      "    %2691 = llvm.fmul %arg1, %2690  : f32\n",
+      "    %2692 = llvm.mlir.constant(0.114797138 : f32) : f32\n",
+      "    %2693 = llvm.mlir.constant(-0.56365943 : f32) : f32\n",
+      "    %2694 = llvm.fmul %arg0, %2693  : f32\n",
+      "    %2695 = llvm.fadd %2694, %2692  : f32\n",
+      "    %2696 = llvm.fadd %2691, %2695  : f32\n",
+      "    %2697 = llvm.intr.maximum(%2696, %2689)  : (f32, f32) -> f32\n",
+      "    %2698 = llvm.mlir.constant(0.56037128 : f32) : f32\n",
+      "    %2699 = llvm.fmul %2697, %2698  : f32\n",
+      "    %2700 = llvm.fadd %2688, %2699  : f32\n",
+      "    %2701 = llvm.mlir.constant(-0.671603084 : f32) : f32\n",
+      "    %2702 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2703 = llvm.mlir.constant(-0.57726413 : f32) : f32\n",
+      "    %2704 = llvm.fmul %arg1, %2703  : f32\n",
+      "    %2705 = llvm.mlir.constant(0.598408341 : f32) : f32\n",
+      "    %2706 = llvm.fmul %arg0, %2705  : f32\n",
+      "    %2707 = llvm.mlir.constant(-0.580251634 : f32) : f32\n",
+      "    %2708 = llvm.fadd %2706, %2707  : f32\n",
+      "    %2709 = llvm.fadd %2704, %2708  : f32\n",
+      "    %2710 = llvm.intr.maximum(%2709, %2702)  : (f32, f32) -> f32\n",
+      "    %2711 = llvm.fmul %2710, %2701  : f32\n",
+      "    %2712 = llvm.fadd %2700, %2711  : f32\n",
+      "    %2713 = llvm.mlir.constant(0.0733986348 : f32) : f32\n",
+      "    %2714 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2715 = llvm.mlir.constant(0.49928996 : f32) : f32\n",
+      "    %2716 = llvm.fmul %arg1, %2715  : f32\n",
+      "    %2717 = llvm.mlir.constant(-0.283014119 : f32) : f32\n",
+      "    %2718 = llvm.fmul %arg0, %2717  : f32\n",
+      "    %2719 = llvm.mlir.constant(0.0311395917 : f32) : f32\n",
+      "    %2720 = llvm.fadd %2718, %2719  : f32\n",
+      "    %2721 = llvm.fadd %2716, %2720  : f32\n",
+      "    %2722 = llvm.intr.maximum(%2721, %2714)  : (f32, f32) -> f32\n",
+      "    %2723 = llvm.fmul %2722, %2713  : f32\n",
+      "    %2724 = llvm.fadd %2712, %2723  : f32\n",
+      "    %2725 = llvm.fadd %2591, %2724  : f32\n",
+      "    %2726 = llvm.mlir.constant(0.159353778 : f32) : f32\n",
+      "    %2727 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2728 = llvm.mlir.constant(0.315162152 : f32) : f32\n",
+      "    %2729 = llvm.mlir.constant(0.600057721 : f32) : f32\n",
+      "    %2730 = llvm.fmul %arg0, %2729  : f32\n",
+      "    %2731 = llvm.fadd %2730, %2728  : f32\n",
+      "    %2732 = llvm.mlir.constant(-0.313983649 : f32) : f32\n",
+      "    %2733 = llvm.fmul %arg1, %2732  : f32\n",
+      "    %2734 = llvm.fadd %2731, %2733  : f32\n",
+      "    %2735 = llvm.intr.maximum(%2734, %2727)  : (f32, f32) -> f32\n",
+      "    %2736 = llvm.fmul %2735, %2726  : f32\n",
+      "    %2737 = llvm.fadd %2725, %2736  : f32\n",
+      "    %2738 = llvm.mlir.constant(-0.739231526 : f32) : f32\n",
+      "    %2739 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2740 = llvm.mlir.constant(-0.169446096 : f32) : f32\n",
+      "    %2741 = llvm.mlir.constant(-0.215495735 : f32) : f32\n",
+      "    %2742 = llvm.fmul %arg0, %2741  : f32\n",
+      "    %2743 = llvm.fadd %2742, %2740  : f32\n",
+      "    %2744 = llvm.mlir.constant(0.985414206 : f32) : f32\n",
+      "    %2745 = llvm.fmul %arg1, %2744  : f32\n",
+      "    %2746 = llvm.fadd %2743, %2745  : f32\n",
+      "    %2747 = llvm.intr.maximum(%2746, %2739)  : (f32, f32) -> f32\n",
+      "    %2748 = llvm.fmul %2747, %2738  : f32\n",
+      "    %2749 = llvm.fadd %2737, %2748  : f32\n",
+      "    %2750 = llvm.mlir.constant(0.562715709 : f32) : f32\n",
+      "    %2751 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2752 = llvm.mlir.constant(-0.0821817442 : f32) : f32\n",
+      "    %2753 = llvm.fmul %arg1, %2752  : f32\n",
+      "    %2754 = llvm.mlir.constant(-0.732010245 : f32) : f32\n",
+      "    %2755 = llvm.mlir.constant(-0.354400456 : f32) : f32\n",
+      "    %2756 = llvm.fmul %arg0, %2755  : f32\n",
+      "    %2757 = llvm.fadd %2756, %2754  : f32\n",
+      "    %2758 = llvm.fadd %2753, %2757  : f32\n",
+      "    %2759 = llvm.intr.maximum(%2758, %2751)  : (f32, f32) -> f32\n",
+      "    %2760 = llvm.fmul %2759, %2750  : f32\n",
+      "    %2761 = llvm.fadd %2749, %2760  : f32\n",
+      "    %2762 = llvm.fadd %2580, %2761  : f32\n",
+      "    %2763 = llvm.intr.maximum(%2762, %2569)  : (f32, f32) -> f32\n",
+      "    %2764 = llvm.mlir.constant(-0.77405405 : f32) : f32\n",
+      "    %2765 = llvm.fmul %2763, %2764  : f32\n",
+      "    %2766 = llvm.fadd %2568, %2765  : f32\n",
+      "    %2767 = llvm.fadd %1181, %2766  : f32\n",
+      "    %2768 = llvm.mlir.constant(0.310977638 : f32) : f32\n",
+      "    %2769 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2770 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2771 = llvm.mlir.constant(-0.148220554 : f32) : f32\n",
+      "    %2772 = llvm.mlir.constant(-0.266904861 : f32) : f32\n",
+      "    %2773 = llvm.fmul %arg0, %2772  : f32\n",
+      "    %2774 = llvm.fadd %2773, %2771  : f32\n",
+      "    %2775 = llvm.mlir.constant(0.591641366 : f32) : f32\n",
+      "    %2776 = llvm.fmul %arg1, %2775  : f32\n",
+      "    %2777 = llvm.fadd %2774, %2776  : f32\n",
+      "    %2778 = llvm.intr.maximum(%2777, %2770)  : (f32, f32) -> f32\n",
+      "    %2779 = llvm.mlir.constant(0.558428347 : f32) : f32\n",
+      "    %2780 = llvm.fmul %2778, %2779  : f32\n",
+      "    %2781 = llvm.mlir.constant(0.385918468 : f32) : f32\n",
+      "    %2782 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2783 = llvm.mlir.constant(0.73282814 : f32) : f32\n",
+      "    %2784 = llvm.fmul %arg1, %2783  : f32\n",
+      "    %2785 = llvm.mlir.constant(-0.632541954 : f32) : f32\n",
+      "    %2786 = llvm.fmul %arg0, %2785  : f32\n",
+      "    %2787 = llvm.mlir.constant(-0.0431155674 : f32) : f32\n",
+      "    %2788 = llvm.fadd %2786, %2787  : f32\n",
+      "    %2789 = llvm.fadd %2784, %2788  : f32\n",
+      "    %2790 = llvm.intr.maximum(%2789, %2782)  : (f32, f32) -> f32\n",
+      "    %2791 = llvm.fmul %2790, %2781  : f32\n",
+      "    %2792 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2793 = llvm.mlir.constant(0.250564575 : f32) : f32\n",
+      "    %2794 = llvm.fmul %arg1, %2793  : f32\n",
+      "    %2795 = llvm.mlir.constant(-0.234713525 : f32) : f32\n",
+      "    %2796 = llvm.mlir.constant(-0.0761275962 : f32) : f32\n",
+      "    %2797 = llvm.fmul %arg0, %2796  : f32\n",
+      "    %2798 = llvm.fadd %2797, %2795  : f32\n",
+      "    %2799 = llvm.fadd %2794, %2798  : f32\n",
+      "    %2800 = llvm.intr.maximum(%2799, %2792)  : (f32, f32) -> f32\n",
+      "    %2801 = llvm.mlir.constant(0.513394475 : f32) : f32\n",
+      "    %2802 = llvm.fmul %2800, %2801  : f32\n",
+      "    %2803 = llvm.mlir.constant(0.0205269028 : f32) : f32\n",
+      "    %2804 = llvm.fadd %2802, %2803  : f32\n",
+      "    %2805 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2806 = llvm.mlir.constant(-0.710041642 : f32) : f32\n",
+      "    %2807 = llvm.fmul %arg0, %2806  : f32\n",
+      "    %2808 = llvm.mlir.constant(-0.179663792 : f32) : f32\n",
+      "    %2809 = llvm.fadd %2807, %2808  : f32\n",
+      "    %2810 = llvm.mlir.constant(0.5115695 : f32) : f32\n",
+      "    %2811 = llvm.fmul %arg1, %2810  : f32\n",
+      "    %2812 = llvm.fadd %2809, %2811  : f32\n",
+      "    %2813 = llvm.intr.maximum(%2812, %2805)  : (f32, f32) -> f32\n",
+      "    %2814 = llvm.mlir.constant(0.260153353 : f32) : f32\n",
+      "    %2815 = llvm.fmul %2813, %2814  : f32\n",
+      "    %2816 = llvm.fadd %2804, %2815  : f32\n",
+      "    %2817 = llvm.fadd %2791, %2816  : f32\n",
+      "    %2818 = llvm.fadd %2780, %2817  : f32\n",
+      "    %2819 = llvm.mlir.constant(0.0462723486 : f32) : f32\n",
+      "    %2820 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2821 = llvm.mlir.constant(-0.732560634 : f32) : f32\n",
+      "    %2822 = llvm.mlir.constant(0.659632384 : f32) : f32\n",
+      "    %2823 = llvm.fmul %arg0, %2822  : f32\n",
+      "    %2824 = llvm.fadd %2823, %2821  : f32\n",
+      "    %2825 = llvm.mlir.constant(-0.124262765 : f32) : f32\n",
+      "    %2826 = llvm.fmul %arg1, %2825  : f32\n",
+      "    %2827 = llvm.fadd %2824, %2826  : f32\n",
+      "    %2828 = llvm.intr.maximum(%2827, %2820)  : (f32, f32) -> f32\n",
+      "    %2829 = llvm.fmul %2828, %2819  : f32\n",
+      "    %2830 = llvm.fadd %2818, %2829  : f32\n",
+      "    %2831 = llvm.mlir.constant(0.743878304 : f32) : f32\n",
+      "    %2832 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2833 = llvm.mlir.constant(-1.00863016 : f32) : f32\n",
+      "    %2834 = llvm.fmul %arg1, %2833  : f32\n",
+      "    %2835 = llvm.mlir.constant(-1.543290e+00 : f32) : f32\n",
+      "    %2836 = llvm.mlir.constant(1.41260469 : f32) : f32\n",
+      "    %2837 = llvm.fmul %arg0, %2836  : f32\n",
+      "    %2838 = llvm.fadd %2837, %2835  : f32\n",
+      "    %2839 = llvm.fadd %2834, %2838  : f32\n",
+      "    %2840 = llvm.intr.maximum(%2839, %2832)  : (f32, f32) -> f32\n",
+      "    %2841 = llvm.fmul %2840, %2831  : f32\n",
+      "    %2842 = llvm.fadd %2830, %2841  : f32\n",
+      "    %2843 = llvm.mlir.constant(0.360693961 : f32) : f32\n",
+      "    %2844 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2845 = llvm.mlir.constant(9.201580e-01 : f32) : f32\n",
+      "    %2846 = llvm.fmul %arg0, %2845  : f32\n",
+      "    %2847 = llvm.mlir.constant(-0.444333524 : f32) : f32\n",
+      "    %2848 = llvm.fadd %2846, %2847  : f32\n",
+      "    %2849 = llvm.mlir.constant(0.859033763 : f32) : f32\n",
+      "    %2850 = llvm.fmul %arg1, %2849  : f32\n",
+      "    %2851 = llvm.fadd %2848, %2850  : f32\n",
+      "    %2852 = llvm.intr.maximum(%2851, %2844)  : (f32, f32) -> f32\n",
+      "    %2853 = llvm.fmul %2852, %2843  : f32\n",
+      "    %2854 = llvm.fadd %2842, %2853  : f32\n",
+      "    %2855 = llvm.mlir.constant(0.454822391 : f32) : f32\n",
+      "    %2856 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2857 = llvm.mlir.constant(0.766540825 : f32) : f32\n",
+      "    %2858 = llvm.fmul %arg1, %2857  : f32\n",
+      "    %2859 = llvm.mlir.constant(-0.924045622 : f32) : f32\n",
+      "    %2860 = llvm.fmul %arg0, %2859  : f32\n",
+      "    %2861 = llvm.mlir.constant(-0.259199619 : f32) : f32\n",
+      "    %2862 = llvm.fadd %2860, %2861  : f32\n",
+      "    %2863 = llvm.fadd %2858, %2862  : f32\n",
+      "    %2864 = llvm.intr.maximum(%2863, %2856)  : (f32, f32) -> f32\n",
+      "    %2865 = llvm.fmul %2864, %2855  : f32\n",
+      "    %2866 = llvm.fadd %2854, %2865  : f32\n",
+      "    %2867 = llvm.mlir.constant(-0.93597114 : f32) : f32\n",
+      "    %2868 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2869 = llvm.mlir.constant(-0.771490633 : f32) : f32\n",
+      "    %2870 = llvm.fmul %arg1, %2869  : f32\n",
+      "    %2871 = llvm.mlir.constant(0.114797138 : f32) : f32\n",
+      "    %2872 = llvm.mlir.constant(-0.56365943 : f32) : f32\n",
+      "    %2873 = llvm.fmul %arg0, %2872  : f32\n",
+      "    %2874 = llvm.fadd %2873, %2871  : f32\n",
+      "    %2875 = llvm.fadd %2870, %2874  : f32\n",
+      "    %2876 = llvm.intr.maximum(%2875, %2868)  : (f32, f32) -> f32\n",
+      "    %2877 = llvm.fmul %2876, %2867  : f32\n",
+      "    %2878 = llvm.fadd %2866, %2877  : f32\n",
+      "    %2879 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2880 = llvm.mlir.constant(-0.57726413 : f32) : f32\n",
+      "    %2881 = llvm.fmul %arg1, %2880  : f32\n",
+      "    %2882 = llvm.mlir.constant(0.598408341 : f32) : f32\n",
+      "    %2883 = llvm.fmul %arg0, %2882  : f32\n",
+      "    %2884 = llvm.mlir.constant(-0.580251634 : f32) : f32\n",
+      "    %2885 = llvm.fadd %2883, %2884  : f32\n",
+      "    %2886 = llvm.fadd %2881, %2885  : f32\n",
+      "    %2887 = llvm.intr.maximum(%2886, %2879)  : (f32, f32) -> f32\n",
+      "    %2888 = llvm.mlir.constant(-0.0872408524 : f32) : f32\n",
+      "    %2889 = llvm.fmul %2887, %2888  : f32\n",
+      "    %2890 = llvm.fadd %2878, %2889  : f32\n",
+      "    %2891 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2892 = llvm.mlir.constant(0.49928996 : f32) : f32\n",
+      "    %2893 = llvm.fmul %arg1, %2892  : f32\n",
+      "    %2894 = llvm.mlir.constant(-0.283014119 : f32) : f32\n",
+      "    %2895 = llvm.fmul %arg0, %2894  : f32\n",
+      "    %2896 = llvm.mlir.constant(0.0311395917 : f32) : f32\n",
+      "    %2897 = llvm.fadd %2895, %2896  : f32\n",
+      "    %2898 = llvm.fadd %2893, %2897  : f32\n",
+      "    %2899 = llvm.intr.maximum(%2898, %2891)  : (f32, f32) -> f32\n",
+      "    %2900 = llvm.mlir.constant(0.542610049 : f32) : f32\n",
+      "    %2901 = llvm.fmul %2899, %2900  : f32\n",
+      "    %2902 = llvm.fadd %2890, %2901  : f32\n",
+      "    %2903 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2904 = llvm.mlir.constant(0.58700037 : f32) : f32\n",
+      "    %2905 = llvm.fmul %arg1, %2904  : f32\n",
+      "    %2906 = llvm.mlir.constant(-0.0791633725 : f32) : f32\n",
+      "    %2907 = llvm.fmul %arg0, %2906  : f32\n",
+      "    %2908 = llvm.mlir.constant(-0.478744268 : f32) : f32\n",
+      "    %2909 = llvm.fadd %2907, %2908  : f32\n",
+      "    %2910 = llvm.fadd %2905, %2909  : f32\n",
+      "    %2911 = llvm.intr.maximum(%2910, %2903)  : (f32, f32) -> f32\n",
+      "    %2912 = llvm.mlir.constant(-0.758096992 : f32) : f32\n",
+      "    %2913 = llvm.fmul %2911, %2912  : f32\n",
+      "    %2914 = llvm.fadd %2902, %2913  : f32\n",
+      "    %2915 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2916 = llvm.mlir.constant(0.315162152 : f32) : f32\n",
+      "    %2917 = llvm.mlir.constant(0.600057721 : f32) : f32\n",
+      "    %2918 = llvm.fmul %arg0, %2917  : f32\n",
+      "    %2919 = llvm.fadd %2918, %2916  : f32\n",
+      "    %2920 = llvm.mlir.constant(-0.313983649 : f32) : f32\n",
+      "    %2921 = llvm.fmul %arg1, %2920  : f32\n",
+      "    %2922 = llvm.fadd %2919, %2921  : f32\n",
+      "    %2923 = llvm.intr.maximum(%2922, %2915)  : (f32, f32) -> f32\n",
+      "    %2924 = llvm.mlir.constant(-0.584159195 : f32) : f32\n",
+      "    %2925 = llvm.fmul %2923, %2924  : f32\n",
+      "    %2926 = llvm.fadd %2914, %2925  : f32\n",
+      "    %2927 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2928 = llvm.mlir.constant(-0.169446096 : f32) : f32\n",
+      "    %2929 = llvm.mlir.constant(-0.215495735 : f32) : f32\n",
+      "    %2930 = llvm.fmul %arg0, %2929  : f32\n",
+      "    %2931 = llvm.fadd %2930, %2928  : f32\n",
+      "    %2932 = llvm.mlir.constant(0.985414206 : f32) : f32\n",
+      "    %2933 = llvm.fmul %arg1, %2932  : f32\n",
+      "    %2934 = llvm.fadd %2931, %2933  : f32\n",
+      "    %2935 = llvm.intr.maximum(%2934, %2927)  : (f32, f32) -> f32\n",
+      "    %2936 = llvm.mlir.constant(0.361958772 : f32) : f32\n",
+      "    %2937 = llvm.fmul %2935, %2936  : f32\n",
+      "    %2938 = llvm.fadd %2926, %2937  : f32\n",
+      "    %2939 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2940 = llvm.mlir.constant(-0.0821817442 : f32) : f32\n",
+      "    %2941 = llvm.fmul %arg1, %2940  : f32\n",
+      "    %2942 = llvm.mlir.constant(-0.732010245 : f32) : f32\n",
+      "    %2943 = llvm.mlir.constant(-0.354400456 : f32) : f32\n",
+      "    %2944 = llvm.fmul %arg0, %2943  : f32\n",
+      "    %2945 = llvm.fadd %2944, %2942  : f32\n",
+      "    %2946 = llvm.fadd %2941, %2945  : f32\n",
+      "    %2947 = llvm.intr.maximum(%2946, %2939)  : (f32, f32) -> f32\n",
+      "    %2948 = llvm.mlir.constant(0.870200634 : f32) : f32\n",
+      "    %2949 = llvm.fmul %2947, %2948  : f32\n",
+      "    %2950 = llvm.fadd %2938, %2949  : f32\n",
+      "    %2951 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2952 = llvm.mlir.constant(-0.217542693 : f32) : f32\n",
+      "    %2953 = llvm.mlir.constant(0.876379132 : f32) : f32\n",
+      "    %2954 = llvm.fmul %arg0, %2953  : f32\n",
+      "    %2955 = llvm.fadd %2954, %2952  : f32\n",
+      "    %2956 = llvm.mlir.constant(0.950005471 : f32) : f32\n",
+      "    %2957 = llvm.fmul %arg1, %2956  : f32\n",
+      "    %2958 = llvm.fadd %2955, %2957  : f32\n",
+      "    %2959 = llvm.intr.maximum(%2958, %2951)  : (f32, f32) -> f32\n",
+      "    %2960 = llvm.mlir.constant(3.056850e-01 : f32) : f32\n",
+      "    %2961 = llvm.fmul %2959, %2960  : f32\n",
+      "    %2962 = llvm.fadd %2950, %2961  : f32\n",
+      "    %2963 = llvm.intr.maximum(%2962, %2769)  : (f32, f32) -> f32\n",
+      "    %2964 = llvm.fmul %2963, %2768  : f32\n",
+      "    %2965 = llvm.fadd %2767, %2964  : f32\n",
+      "    %2966 = llvm.fadd %984, %2965  : f32\n",
+      "    %2967 = llvm.mlir.constant(-1.10668659 : f32) : f32\n",
+      "    %2968 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2969 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2970 = llvm.mlir.constant(-0.169446096 : f32) : f32\n",
+      "    %2971 = llvm.mlir.constant(-0.215495735 : f32) : f32\n",
+      "    %2972 = llvm.fmul %arg0, %2971  : f32\n",
+      "    %2973 = llvm.fadd %2972, %2970  : f32\n",
+      "    %2974 = llvm.mlir.constant(0.985414206 : f32) : f32\n",
+      "    %2975 = llvm.fmul %arg1, %2974  : f32\n",
+      "    %2976 = llvm.fadd %2973, %2975  : f32\n",
+      "    %2977 = llvm.intr.maximum(%2976, %2969)  : (f32, f32) -> f32\n",
+      "    %2978 = llvm.mlir.constant(-0.0283254012 : f32) : f32\n",
+      "    %2979 = llvm.fmul %2977, %2978  : f32\n",
+      "    %2980 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2981 = llvm.mlir.constant(0.315162152 : f32) : f32\n",
+      "    %2982 = llvm.mlir.constant(0.600057721 : f32) : f32\n",
+      "    %2983 = llvm.fmul %arg0, %2982  : f32\n",
+      "    %2984 = llvm.fadd %2983, %2981  : f32\n",
+      "    %2985 = llvm.mlir.constant(-0.313983649 : f32) : f32\n",
+      "    %2986 = llvm.fmul %arg1, %2985  : f32\n",
+      "    %2987 = llvm.fadd %2984, %2986  : f32\n",
+      "    %2988 = llvm.intr.maximum(%2987, %2980)  : (f32, f32) -> f32\n",
+      "    %2989 = llvm.mlir.constant(0.238913447 : f32) : f32\n",
+      "    %2990 = llvm.fmul %2988, %2989  : f32\n",
+      "    %2991 = llvm.mlir.constant(-1.36403692 : f32) : f32\n",
+      "    %2992 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %2993 = llvm.mlir.constant(-1.00863016 : f32) : f32\n",
+      "    %2994 = llvm.fmul %arg1, %2993  : f32\n",
+      "    %2995 = llvm.mlir.constant(-1.543290e+00 : f32) : f32\n",
+      "    %2996 = llvm.mlir.constant(1.41260469 : f32) : f32\n",
+      "    %2997 = llvm.fmul %arg0, %2996  : f32\n",
+      "    %2998 = llvm.fadd %2997, %2995  : f32\n",
+      "    %2999 = llvm.fadd %2994, %2998  : f32\n",
+      "    %3000 = llvm.intr.maximum(%2999, %2992)  : (f32, f32) -> f32\n",
+      "    %3001 = llvm.fmul %3000, %2991  : f32\n",
+      "    %3002 = llvm.mlir.constant(-0.0397332087 : f32) : f32\n",
+      "    %3003 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %3004 = llvm.mlir.constant(-0.732560634 : f32) : f32\n",
+      "    %3005 = llvm.mlir.constant(0.659632384 : f32) : f32\n",
+      "    %3006 = llvm.fmul %arg0, %3005  : f32\n",
+      "    %3007 = llvm.fadd %3006, %3004  : f32\n",
+      "    %3008 = llvm.mlir.constant(-0.124262765 : f32) : f32\n",
+      "    %3009 = llvm.fmul %arg1, %3008  : f32\n",
+      "    %3010 = llvm.fadd %3007, %3009  : f32\n",
+      "    %3011 = llvm.intr.maximum(%3010, %3003)  : (f32, f32) -> f32\n",
+      "    %3012 = llvm.fmul %3011, %3002  : f32\n",
+      "    %3013 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %3014 = llvm.mlir.constant(-0.148220554 : f32) : f32\n",
+      "    %3015 = llvm.mlir.constant(-0.266904861 : f32) : f32\n",
+      "    %3016 = llvm.fmul %arg0, %3015  : f32\n",
+      "    %3017 = llvm.fadd %3016, %3014  : f32\n",
+      "    %3018 = llvm.mlir.constant(0.591641366 : f32) : f32\n",
+      "    %3019 = llvm.fmul %arg1, %3018  : f32\n",
+      "    %3020 = llvm.fadd %3017, %3019  : f32\n",
+      "    %3021 = llvm.intr.maximum(%3020, %3013)  : (f32, f32) -> f32\n",
+      "    %3022 = llvm.mlir.constant(-0.205060512 : f32) : f32\n",
+      "    %3023 = llvm.fmul %3021, %3022  : f32\n",
+      "    %3024 = llvm.mlir.constant(0.350935221 : f32) : f32\n",
+      "    %3025 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %3026 = llvm.mlir.constant(0.73282814 : f32) : f32\n",
+      "    %3027 = llvm.fmul %arg1, %3026  : f32\n",
+      "    %3028 = llvm.mlir.constant(-0.632541954 : f32) : f32\n",
+      "    %3029 = llvm.fmul %arg0, %3028  : f32\n",
+      "    %3030 = llvm.mlir.constant(-0.0431155674 : f32) : f32\n",
+      "    %3031 = llvm.fadd %3029, %3030  : f32\n",
+      "    %3032 = llvm.fadd %3027, %3031  : f32\n",
+      "    %3033 = llvm.intr.maximum(%3032, %3025)  : (f32, f32) -> f32\n",
+      "    %3034 = llvm.fmul %3033, %3024  : f32\n",
+      "    %3035 = llvm.mlir.constant(-0.0946805477 : f32) : f32\n",
+      "    %3036 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %3037 = llvm.mlir.constant(0.250564575 : f32) : f32\n",
+      "    %3038 = llvm.fmul %arg1, %3037  : f32\n",
+      "    %3039 = llvm.mlir.constant(-0.234713525 : f32) : f32\n",
+      "    %3040 = llvm.mlir.constant(-0.0761275962 : f32) : f32\n",
+      "    %3041 = llvm.fmul %arg0, %3040  : f32\n",
+      "    %3042 = llvm.fadd %3041, %3039  : f32\n",
+      "    %3043 = llvm.fadd %3038, %3042  : f32\n",
+      "    %3044 = llvm.intr.maximum(%3043, %3036)  : (f32, f32) -> f32\n",
+      "    %3045 = llvm.mlir.constant(-0.834079563 : f32) : f32\n",
+      "    %3046 = llvm.fmul %3044, %3045  : f32\n",
+      "    %3047 = llvm.fadd %3046, %3035  : f32\n",
+      "    %3048 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %3049 = llvm.mlir.constant(-0.710041642 : f32) : f32\n",
+      "    %3050 = llvm.fmul %arg0, %3049  : f32\n",
+      "    %3051 = llvm.mlir.constant(-0.179663792 : f32) : f32\n",
+      "    %3052 = llvm.fadd %3050, %3051  : f32\n",
+      "    %3053 = llvm.mlir.constant(0.5115695 : f32) : f32\n",
+      "    %3054 = llvm.fmul %arg1, %3053  : f32\n",
+      "    %3055 = llvm.fadd %3052, %3054  : f32\n",
+      "    %3056 = llvm.intr.maximum(%3055, %3048)  : (f32, f32) -> f32\n",
+      "    %3057 = llvm.mlir.constant(0.66370052 : f32) : f32\n",
+      "    %3058 = llvm.fmul %3056, %3057  : f32\n",
+      "    %3059 = llvm.fadd %3047, %3058  : f32\n",
+      "    %3060 = llvm.fadd %3034, %3059  : f32\n",
+      "    %3061 = llvm.fadd %3023, %3060  : f32\n",
+      "    %3062 = llvm.fadd %3012, %3061  : f32\n",
+      "    %3063 = llvm.fadd %3001, %3062  : f32\n",
+      "    %3064 = llvm.mlir.constant(0.85548079 : f32) : f32\n",
+      "    %3065 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %3066 = llvm.mlir.constant(9.201580e-01 : f32) : f32\n",
+      "    %3067 = llvm.fmul %arg0, %3066  : f32\n",
+      "    %3068 = llvm.mlir.constant(-0.444333524 : f32) : f32\n",
+      "    %3069 = llvm.fadd %3067, %3068  : f32\n",
+      "    %3070 = llvm.mlir.constant(0.859033763 : f32) : f32\n",
+      "    %3071 = llvm.fmul %arg1, %3070  : f32\n",
+      "    %3072 = llvm.fadd %3069, %3071  : f32\n",
+      "    %3073 = llvm.intr.maximum(%3072, %3065)  : (f32, f32) -> f32\n",
+      "    %3074 = llvm.fmul %3073, %3064  : f32\n",
+      "    %3075 = llvm.fadd %3063, %3074  : f32\n",
+      "    %3076 = llvm.mlir.constant(0.452764273 : f32) : f32\n",
+      "    %3077 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %3078 = llvm.mlir.constant(0.766540825 : f32) : f32\n",
+      "    %3079 = llvm.fmul %arg1, %3078  : f32\n",
+      "    %3080 = llvm.mlir.constant(-0.924045622 : f32) : f32\n",
+      "    %3081 = llvm.fmul %arg0, %3080  : f32\n",
+      "    %3082 = llvm.mlir.constant(-0.259199619 : f32) : f32\n",
+      "    %3083 = llvm.fadd %3081, %3082  : f32\n",
+      "    %3084 = llvm.fadd %3079, %3083  : f32\n",
+      "    %3085 = llvm.intr.maximum(%3084, %3077)  : (f32, f32) -> f32\n",
+      "    %3086 = llvm.fmul %3085, %3076  : f32\n",
+      "    %3087 = llvm.fadd %3075, %3086  : f32\n",
+      "    %3088 = llvm.mlir.constant(0.913521647 : f32) : f32\n",
+      "    %3089 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %3090 = llvm.mlir.constant(-0.771490633 : f32) : f32\n",
+      "    %3091 = llvm.fmul %arg1, %3090  : f32\n",
+      "    %3092 = llvm.mlir.constant(0.114797138 : f32) : f32\n",
+      "    %3093 = llvm.mlir.constant(-0.56365943 : f32) : f32\n",
+      "    %3094 = llvm.fmul %arg0, %3093  : f32\n",
+      "    %3095 = llvm.fadd %3094, %3092  : f32\n",
+      "    %3096 = llvm.fadd %3091, %3095  : f32\n",
+      "    %3097 = llvm.intr.maximum(%3096, %3089)  : (f32, f32) -> f32\n",
+      "    %3098 = llvm.fmul %3097, %3088  : f32\n",
+      "    %3099 = llvm.fadd %3087, %3098  : f32\n",
+      "    %3100 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %3101 = llvm.mlir.constant(-0.57726413 : f32) : f32\n",
+      "    %3102 = llvm.fmul %arg1, %3101  : f32\n",
+      "    %3103 = llvm.mlir.constant(0.598408341 : f32) : f32\n",
+      "    %3104 = llvm.fmul %arg0, %3103  : f32\n",
+      "    %3105 = llvm.mlir.constant(-0.580251634 : f32) : f32\n",
+      "    %3106 = llvm.fadd %3104, %3105  : f32\n",
+      "    %3107 = llvm.fadd %3102, %3106  : f32\n",
+      "    %3108 = llvm.intr.maximum(%3107, %3100)  : (f32, f32) -> f32\n",
+      "    %3109 = llvm.mlir.constant(-1.03813553 : f32) : f32\n",
+      "    %3110 = llvm.fmul %3108, %3109  : f32\n",
+      "    %3111 = llvm.fadd %3099, %3110  : f32\n",
+      "    %3112 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %3113 = llvm.mlir.constant(0.49928996 : f32) : f32\n",
+      "    %3114 = llvm.fmul %arg1, %3113  : f32\n",
+      "    %3115 = llvm.mlir.constant(-0.283014119 : f32) : f32\n",
+      "    %3116 = llvm.fmul %arg0, %3115  : f32\n",
+      "    %3117 = llvm.mlir.constant(0.0311395917 : f32) : f32\n",
+      "    %3118 = llvm.fadd %3116, %3117  : f32\n",
+      "    %3119 = llvm.fadd %3114, %3118  : f32\n",
+      "    %3120 = llvm.intr.maximum(%3119, %3112)  : (f32, f32) -> f32\n",
+      "    %3121 = llvm.mlir.constant(0.188292861 : f32) : f32\n",
+      "    %3122 = llvm.fmul %3120, %3121  : f32\n",
+      "    %3123 = llvm.fadd %3111, %3122  : f32\n",
+      "    %3124 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %3125 = llvm.mlir.constant(0.58700037 : f32) : f32\n",
+      "    %3126 = llvm.fmul %arg1, %3125  : f32\n",
+      "    %3127 = llvm.mlir.constant(-0.0791633725 : f32) : f32\n",
+      "    %3128 = llvm.fmul %arg0, %3127  : f32\n",
+      "    %3129 = llvm.mlir.constant(-0.478744268 : f32) : f32\n",
+      "    %3130 = llvm.fadd %3128, %3129  : f32\n",
+      "    %3131 = llvm.fadd %3126, %3130  : f32\n",
+      "    %3132 = llvm.intr.maximum(%3131, %3124)  : (f32, f32) -> f32\n",
+      "    %3133 = llvm.mlir.constant(-0.721292853 : f32) : f32\n",
+      "    %3134 = llvm.fmul %3132, %3133  : f32\n",
+      "    %3135 = llvm.fadd %3123, %3134  : f32\n",
+      "    %3136 = llvm.fadd %2990, %3135  : f32\n",
+      "    %3137 = llvm.fadd %2979, %3136  : f32\n",
+      "    %3138 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %3139 = llvm.mlir.constant(-0.0821817442 : f32) : f32\n",
+      "    %3140 = llvm.fmul %arg1, %3139  : f32\n",
+      "    %3141 = llvm.mlir.constant(-0.732010245 : f32) : f32\n",
+      "    %3142 = llvm.mlir.constant(-0.354400456 : f32) : f32\n",
+      "    %3143 = llvm.fmul %arg0, %3142  : f32\n",
+      "    %3144 = llvm.fadd %3143, %3141  : f32\n",
+      "    %3145 = llvm.fadd %3140, %3144  : f32\n",
+      "    %3146 = llvm.intr.maximum(%3145, %3138)  : (f32, f32) -> f32\n",
+      "    %3147 = llvm.mlir.constant(-0.438127905 : f32) : f32\n",
+      "    %3148 = llvm.fmul %3146, %3147  : f32\n",
+      "    %3149 = llvm.fadd %3137, %3148  : f32\n",
+      "    %3150 = llvm.mlir.constant(0.000000e+00 : f32) : f32\n",
+      "    %3151 = llvm.mlir.constant(-0.217542693 : f32) : f32\n",
+      "    %3152 = llvm.mlir.constant(0.876379132 : f32) : f32\n",
+      "    %3153 = llvm.fmul %arg0, %3152  : f32\n",
+      "    %3154 = llvm.fadd %3153, %3151  : f32\n",
+      "    %3155 = llvm.mlir.constant(0.950005471 : f32) : f32\n",
+      "    %3156 = llvm.fmul %arg1, %3155  : f32\n",
+      "    %3157 = llvm.fadd %3154, %3156  : f32\n",
+      "    %3158 = llvm.intr.maximum(%3157, %3150)  : (f32, f32) -> f32\n",
+      "    %3159 = llvm.mlir.constant(0.137311101 : f32) : f32\n",
+      "    %3160 = llvm.fmul %3158, %3159  : f32\n",
+      "    %3161 = llvm.fadd %3149, %3160  : f32\n",
+      "    %3162 = llvm.intr.maximum(%3161, %2968)  : (f32, f32) -> f32\n",
+      "    %3163 = llvm.fmul %3162, %2967  : f32\n",
+      "    %3164 = llvm.fadd %2966, %3163  : f32\n",
+      "    %3165 = llvm.fadd %787, %3164  : f32\n",
+      "    %3166 = llvm.fadd %590, %3165  : f32\n",
+      "    %3167 = llvm.fadd %393, %3166  : f32\n",
+      "    %3168 = llvm.fadd %196, %3167  : f32\n",
+      "    llvm.return %3168 : f32\n",
+      "  }\n",
+      "  llvm.func @_mlir_ciface_main(%arg0: f32, %arg1: f32) -> f32 attributes {llvm.emit_c_interface} {\n",
+      "    %0 = llvm.call @main(%arg0, %arg1) : (f32, f32) -> f32\n",
+      "    llvm.return %0 : f32\n",
+      "  }\n",
+      "}\n",
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(-1.548639298268643, 1.951360701731357)"
+      ]
+     },
+     "execution_count": 33,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from micrograd.jit import jit\n",
+    "\n",
+    "# jit the model\n",
+    "jmodel = jit(model)\n",
+    "\n",
+    "# print the MLIR JIT\n",
+    "print(jmodel)\n",
+    "\n",
+    "# This is a copy of the earlier cell but with the model replaced by the jitted model\n",
+    "# visualize decision boundary\n",
+    "\n",
+    "h = 0.25\n",
+    "x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1\n",
+    "y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1\n",
+    "xx, yy = np.meshgrid(np.arange(x_min, x_max, h),\n",
+    "                     np.arange(y_min, y_max, h))\n",
+    "Xmesh = np.c_[xx.ravel(), yy.ravel()]\n",
+    "# We don't need to pass Value to the compiled model\n",
+    "inputs = Xmesh\n",
+    "scores = list(map(jmodel, inputs))\n",
+    "Z = np.array([s > 0 for s in scores])\n",
+    "Z = Z.reshape(xx.shape)\n",
+    "\n",
+    "fig = plt.figure()\n",
+    "plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral, alpha=0.8)\n",
+    "plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.Spectral)\n",
+    "plt.xlim(xx.min(), xx.max())\n",
+    "plt.ylim(yy.min(), yy.max())\n"
+   ]
   }
  ],
  "metadata": {
@@ -345,7 +3580,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.5"
+   "version": "3.11.7"
   }
  },
  "nbformat": 4,

From 0b5ac71af319ef4888dfa406f13445d89aa1f3e4 Mon Sep 17 00:00:00 2001
From: Alexander Shaposhnikov <ashaposhnikov@google.com>
Date: Sat, 2 Mar 2024 10:26:03 +0000
Subject: [PATCH 21/22] Add a toy benchmark

---
 test/test_jit.py | 25 ++++++++++++++++++++++---
 1 file changed, 22 insertions(+), 3 deletions(-)

diff --git a/test/test_jit.py b/test/test_jit.py
index 61bf4dec..82d4c6c7 100644
--- a/test/test_jit.py
+++ b/test/test_jit.py
@@ -1,5 +1,6 @@
 import math
 import random
+import timeit
 from micrograd.engine import Value
 from micrograd.nn import Neuron, Layer, MLP
 from micrograd.jit import jit
@@ -32,15 +33,16 @@ def test_layer():
     args = [-30., -20.]
     assert math.isclose(l(args).data, jl(args), abs_tol=1e-04)
 
+
 def test_layer_multiple_out():
     random.seed(10)
     l = Layer(nin=2, nout=2)
     jl = jit(l)
-    print(jl)
     args = [-30., -20.]
     for r, jr in zip(l(args), jl(args)):
         assert math.isclose(r.data, jr, abs_tol=1e-04)
-    
+
+
 def test_mlp():
     random.seed(10)
     nn = MLP(nin=2, nouts=[1])
@@ -56,6 +58,7 @@ def test_mlp_complex():
     args = [-30., -20.]
     assert math.isclose(nn(args).data, jnn(args), abs_tol=1e-04)
 
+
 def test_mlp_complex_multiple_out():
     random.seed(10)
     nn = MLP(nin=2, nouts=[2, 2])
@@ -63,4 +66,20 @@ def test_mlp_complex_multiple_out():
     args = [-30., -20.]
     for r, jr in zip(nn(args), jnn(args)):
         assert math.isclose(r.data, jr, abs_tol=1e-04)
-    
+
+
+def test_mlp_performance():
+    random.seed(10)
+    nn = MLP(nin=10, nouts=[30, 20, 10, 1])
+    args = random.sample(range(-100, 100), 10)
+    jnn = jit(nn)
+
+    def slow_inference():
+        return nn(args)
+
+    def fast_inference():
+        return jnn(args)
+    slow_inference_time = timeit.timeit(slow_inference, number=1000)
+    fast_inference_time = timeit.timeit(fast_inference, number=1000)
+    print(f"\nslow: {slow_inference_time}\nfast: {fast_inference_time}")
+    assert slow_inference_time > fast_inference_time

From d3e5e4d8111b3e08b401ba69a4d413b29cbe803d Mon Sep 17 00:00:00 2001
From: Farid Zakaria <fmzakari@google.com>
Date: Sat, 2 Mar 2024 22:57:02 +0000
Subject: [PATCH 22/22] Format test_jit.py

---
 test/test_jit.py | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/test/test_jit.py b/test/test_jit.py
index 82d4c6c7..d191e59a 100644
--- a/test/test_jit.py
+++ b/test/test_jit.py
@@ -4,8 +4,10 @@
 from micrograd.engine import Value
 from micrograd.nn import Neuron, Layer, MLP
 from micrograd.jit import jit
+
 # helps investigate segmentation faults
 import faulthandler
+
 faulthandler.enable()
 
 
@@ -20,7 +22,7 @@ def test_value():
 
 def test_neuron():
     n = Neuron(nin=1, nonlin=False)
-    n.w = [2.]
+    n.w = [2.0]
     jn = jit(n)
     args = [10.0]
     assert math.isclose(n(args).data, jn(args), abs_tol=1e-04)
@@ -30,7 +32,7 @@ def test_layer():
     random.seed(10)
     l = Layer(nin=2, nout=1)
     jl = jit(l)
-    args = [-30., -20.]
+    args = [-30.0, -20.0]
     assert math.isclose(l(args).data, jl(args), abs_tol=1e-04)
 
 
@@ -38,7 +40,7 @@ def test_layer_multiple_out():
     random.seed(10)
     l = Layer(nin=2, nout=2)
     jl = jit(l)
-    args = [-30., -20.]
+    args = [-30.0, -20.0]
     for r, jr in zip(l(args), jl(args)):
         assert math.isclose(r.data, jr, abs_tol=1e-04)
 
@@ -47,7 +49,7 @@ def test_mlp():
     random.seed(10)
     nn = MLP(nin=2, nouts=[1])
     jnn = jit(nn)
-    args = [-30., -20.]
+    args = [-30.0, -20.0]
     assert math.isclose(nn(args).data, jnn(args), abs_tol=1e-04)
 
 
@@ -55,7 +57,7 @@ def test_mlp_complex():
     random.seed(10)
     nn = MLP(nin=2, nouts=[2, 1])
     jnn = jit(nn)
-    args = [-30., -20.]
+    args = [-30.0, -20.0]
     assert math.isclose(nn(args).data, jnn(args), abs_tol=1e-04)
 
 
@@ -63,7 +65,7 @@ def test_mlp_complex_multiple_out():
     random.seed(10)
     nn = MLP(nin=2, nouts=[2, 2])
     jnn = jit(nn)
-    args = [-30., -20.]
+    args = [-30.0, -20.0]
     for r, jr in zip(nn(args), jnn(args)):
         assert math.isclose(r.data, jr, abs_tol=1e-04)
 
@@ -79,6 +81,7 @@ def slow_inference():
 
     def fast_inference():
         return jnn(args)
+
     slow_inference_time = timeit.timeit(slow_inference, number=1000)
     fast_inference_time = timeit.timeit(fast_inference, number=1000)
     print(f"\nslow: {slow_inference_time}\nfast: {fast_inference_time}")