Repository: BayesWitnesses/m2cgen (language: rust)

Issue:
drop numpy dependency from Python code for cases without vectors
According to this line, it seems that `numpy` is used as a default math library for runtime even when we do not operate with vectors.
https://github.com/BayesWitnesses/m2cgen/blob/2475f3cddb5b328c8673795ca3cbe4fdc89f6797/m2cgen/interpreters/python/interpreter.py#L30-L31

Let me describe two advantages of dropping `numpy` where it's possible.

The first one is **excess dependence**. Even though `numpy` is a sort of "classic" dependence and there should be no problems with installing it, it requires additional manipulation from a user side. Also, there are some companies with very strict security policies, which prohibit using pip (conda, brew, and other package managers). So, I guess, for them raw Python may be preferable solution in cases where it's possible.

The second one is **speed**. `numpy` is about efficient **vector** math, in other cases it only produces redundant computational cost. Consider the following example. Take [this generated Python code from the repo](https://github.com/BayesWitnesses/m2cgen/blob/master/generated_code_examples/python/classification/svm.py), change return type from `np.array` to simple `list`, replace the following things in script:
- `numpy` -> `math`
- `np.exp` -> `math.exp`
- `np.power` -> `math.pow`

Here what we get after removing `numpy`:
```
import math
def score_raw(input):
    var0 = (0) - (0.25)
    var1 = math.exp((var0) * ((((math.pow((5.4) - (input[0]), 2)) + (math.pow((3.0) - (input[1]), 2))) + (math.pow((4.5) - (input[2]), 2))) + (math.pow((1.5) - (input[3]), 2))))
    var2 = math.exp((var0) * ((((math.pow((6.2) - (input[0]), 2)) + (math.pow((2.2) - (input[1]), 2))) + (math.pow((4.5) - (input[2]), 2))) + (math.pow((1.5) - (input[3]), 2))))
    var3 = math.exp((var0) * ((((math.pow((5.0) - (input[0]), 2)) + (math.pow((2.3) - (input[1]), 2))) + (math.pow((3.3) - (input[2]), 2))) + (math.pow((1.0) - (input[3]), 2))))
    var4 = math.exp((var0) * ((((math.pow((5.9) - (input[0]), 2)) + (math.pow((3.2) - (input[1]), 2))) + (math.pow((4.8) - (input[2]), 2))) + (math.pow((1.8) - (input[3]), 2))))
    var5 = math.exp((var0) * ((((math.pow((5.0) - (input[0]), 2)) + (math.pow((2.0) - (input[1]), 2))) + (math.pow((3.5) - (input[2]), 2))) + (math.pow((1.0) - (input[3]), 2))))
    var6 = math.exp((var0) * ((((math.pow((6.7) - (input[0]), 2)) + (math.pow((3.0) - (input[1]), 2))) + (math.pow((5.0) - (input[2]), 2))) + (math.pow((1.7) - (input[3]), 2))))
    var7 = math.exp((var0) * ((((math.pow((7.0) - (input[0]), 2)) + (math.pow((3.2) - (input[1]), 2))) + (math.pow((4.7) - (input[2]), 2))) + (math.pow((1.4) - (input[3]), 2))))
    var8 = math.exp((var0) * ((((math.pow((4.9) - (input[0]), 2)) + (math.pow((2.4) - (input[1]), 2))) + (math.pow((3.3) - (input[2]), 2))) + (math.pow((1.0) - (input[3]), 2))))
    var9 = math.exp((var0) * ((((math.pow((6.3) - (input[0]), 2)) + (math.pow((2.5) - (input[1]), 2))) + (math.pow((4.9) - (input[2]), 2))) + (math.pow((1.5) - (input[3]), 2))))
    var10 = math.exp((var0) * ((((math.pow((6.0) - (input[0]), 2)) + (math.pow((2.7) - (input[1]), 2))) + (math.pow((5.1) - (input[2]), 2))) + (math.pow((1.6) - (input[3]), 2))))
    var11 = math.exp((var0) * ((((math.pow((5.7) - (input[0]), 2)) + (math.pow((2.6) - (input[1]), 2))) + (math.pow((3.5) - (input[2]), 2))) + (math.pow((1.0) - (input[3]), 2))))
    var12 = math.exp((var0) * ((((math.pow((5.1) - (input[0]), 2)) + (math.pow((3.8) - (input[1]), 2))) + (math.pow((1.9) - (input[2]), 2))) + (math.pow((0.4) - (input[3]), 2))))
    var13 = math.exp((var0) * ((((math.pow((4.4) - (input[0]), 2)) + (math.pow((2.9) - (input[1]), 2))) + (math.pow((1.4) - (input[2]), 2))) + (math.pow((0.2) - (input[3]), 2))))
    var14 = math.exp((var0) * ((((math.pow((5.7) - (input[0]), 2)) + (math.pow((4.4) - (input[1]), 2))) + (math.pow((1.5) - (input[2]), 2))) + (math.pow((0.4) - (input[3]), 2))))
    var15 = math.exp((var0) * ((((math.pow((5.8) - (input[0]), 2)) + (math.pow((4.0) - (input[1]), 2))) + (math.pow((1.2) - (input[2]), 2))) + (math.pow((0.2) - (input[3]), 2))))
    var16 = math.exp((var0) * ((((math.pow((5.1) - (input[0]), 2)) + (math.pow((3.3) - (input[1]), 2))) + (math.pow((1.7) - (input[2]), 2))) + (math.pow((0.5) - (input[3]), 2))))
    var17 = math.exp((var0) * ((((math.pow((5.7) - (input[0]), 2)) + (math.pow((3.8) - (input[1]), 2))) + (math.pow((1.7) - (input[2]), 2))) + (math.pow((0.3) - (input[3]), 2))))
    var18 = math.exp((var0) * ((((math.pow((4.3) - (input[0]), 2)) + (math.pow((3.0) - (input[1]), 2))) + (math.pow((1.1) - (input[2]), 2))) + (math.pow((0.1) - (input[3]), 2))))
    var19 = math.exp((var0) * ((((math.pow((4.5) - (input[0]), 2)) + (math.pow((2.3) - (input[1]), 2))) + (math.pow((1.3) - (input[2]), 2))) + (math.pow((0.3) - (input[3]), 2))))
    var20 = math.exp((var0) * ((((math.pow((6.3) - (input[0]), 2)) + (math.pow((2.7) - (input[1]), 2))) + (math.pow((4.9) - (input[2]), 2))) + (math.pow((1.8) - (input[3]), 2))))
    var21 = math.exp((var0) * ((((math.pow((6.0) - (input[0]), 2)) + (math.pow((3.0) - (input[1]), 2))) + (math.pow((4.8) - (input[2]), 2))) + (math.pow((1.8) - (input[3]), 2))))
    var22 = math.exp((var0) * ((((math.pow((6.3) - (input[0]), 2)) + (math.pow((2.8) - (input[1]), 2))) + (math.pow((5.1) - (input[2]), 2))) + (math.pow((1.5) - (input[3]), 2))))
    var23 = math.exp((var0) * ((((math.pow((5.8) - (input[0]), 2)) + (math.pow((2.8) - (input[1]), 2))) + (math.pow((5.1) - (input[2]), 2))) + (math.pow((2.4) - (input[3]), 2))))
    var24 = math.exp((var0) * ((((math.pow((6.1) - (input[0]), 2)) + (math.pow((3.0) - (input[1]), 2))) + (math.pow((4.9) - (input[2]), 2))) + (math.pow((1.8) - (input[3]), 2))))
    var25 = math.exp((var0) * ((((math.pow((7.7) - (input[0]), 2)) + (math.pow((2.6) - (input[1]), 2))) + (math.pow((6.9) - (input[2]), 2))) + (math.pow((2.3) - (input[3]), 2))))
    var26 = math.exp((var0) * ((((math.pow((6.9) - (input[0]), 2)) + (math.pow((3.1) - (input[1]), 2))) + (math.pow((5.1) - (input[2]), 2))) + (math.pow((2.3) - (input[3]), 2))))
    var27 = math.exp((var0) * ((((math.pow((6.3) - (input[0]), 2)) + (math.pow((3.3) - (input[1]), 2))) + (math.pow((6.0) - (input[2]), 2))) + (math.pow((2.5) - (input[3]), 2))))
    var28 = math.exp((var0) * ((((math.pow((4.9) - (input[0]), 2)) + (math.pow((2.5) - (input[1]), 2))) + (math.pow((4.5) - (input[2]), 2))) + (math.pow((1.7) - (input[3]), 2))))
    var29 = math.exp((var0) * ((((math.pow((6.0) - (input[0]), 2)) + (math.pow((2.2) - (input[1]), 2))) + (math.pow((5.0) - (input[2]), 2))) + (math.pow((1.5) - (input[3]), 2))))
    var30 = math.exp((var0) * ((((math.pow((7.9) - (input[0]), 2)) + (math.pow((3.8) - (input[1]), 2))) + (math.pow((6.4) - (input[2]), 2))) + (math.pow((2.0) - (input[3]), 2))))
    var31 = math.exp((var0) * ((((math.pow((7.2) - (input[0]), 2)) + (math.pow((3.0) - (input[1]), 2))) + (math.pow((5.8) - (input[2]), 2))) + (math.pow((1.6) - (input[3]), 2))))
    var32 = math.exp((var0) * ((((math.pow((7.7) - (input[0]), 2)) + (math.pow((3.8) - (input[1]), 2))) + (math.pow((6.7) - (input[2]), 2))) + (math.pow((2.2) - (input[3]), 2))))
    return [(((((((((((((((((((-0.08359187780790468) + ((var1) * (-0.0))) + ((var2) * (-0.0))) + ((var3) * (-0.4393498355605194))) + ((var4) * (-0.009465620856664334))) + ((var5) * (-0.16223369966927))) + ((var6) * (-0.26861888775075243))) + ((var7) * (-0.4393498355605194))) + ((var8) * (-0.4393498355605194))) + ((var9) * (-0.0))) + ((var10) * (-0.0))) + ((var11) * (-0.19673905328606292))) + ((var12) * (0.3340655283922188))) + ((var13) * (0.3435087305152051))) + ((var14) * (0.4393498355605194))) + ((var15) * (0.0))) + ((var16) * (0.28614124535416424))) + ((var17) * (0.11269159286168087))) + ((var18) * (0.0))) + ((var19) * (0.4393498355605194)), (((((((((((((((((((((-0.18563912331454907) + ((var20) * (-0.0))) + ((var21) * (-0.06014273244194299))) + ((var22) * (-0.0))) + ((var23) * (-0.031132453078851926))) + ((var24) * (-0.0))) + ((var25) * (-0.3893079321588921))) + ((var26) * (-0.06738007627290196))) + ((var27) * (-0.1225075748937126))) + ((var28) * (-0.3893079321588921))) + ((var29) * (-0.29402231709614085))) + ((var30) * (-0.3893079321588921))) + ((var31) * (-0.0))) + ((var32) * (-0.028242141062729226))) + ((var12) * (0.16634667752431267))) + ((var13) * (0.047772685163074764))) + ((var14) * (0.3893079321588921))) + ((var15) * (0.3893079321588921))) + ((var16) * (0.0))) + ((var17) * (0.0))) + ((var18) * (0.3893079321588921))) + ((var19) * (0.3893079321588921)), ((((((((((((((((((((((((0.5566649875797668) + ((var20) * (-25.563066587228416))) + ((var21) * (-38.35628154976547))) + ((var22) * (-38.35628154976547))) + ((var23) * (-0.0))) + ((var24) * (-38.35628154976547))) + ((var25) * (-0.0))) + ((var26) * (-0.0))) + ((var27) * (-0.0))) + ((var28) * (-6.2260303727828745))) + ((var29) * (-18.42781911624364))) + ((var30) * (-0.14775026537286423))) + ((var31) * (-7.169755983020096))) + ((var32) * (-0.0))) + ((var1) * (12.612328267927264))) + ((var2) * (6.565812506955159))) + ((var3) * (0.0))) + ((var4) * (38.35628154976547))) + ((var5) * (0.0))) + ((var6) * (38.35628154976547))) + ((var7) * (0.0))) + ((var8) * (0.0))) + ((var9) * (38.35628154976547))) + ((var10) * (38.35628154976547))) + ((var11) * (0.0))]
```

And here are some timings:
```
%%timeit -n 10000
score([1, 2, 3, 4])
```
```
310 µs ± 658 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
```

```
%%timeit -n 10000
score_raw([1, 2, 3, 4])
```
```
39.4 µs ± 136 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
```

Results seems to be identical:
```
np.testing.assert_allclose(score([1, 2, 3, 4]), score_raw([1, 2, 3, 4]))
```

Please share your thoughts about this refactoring.


Discussion / hints:
Hey @StrikerRUS! Thanks for creating this issue.

Besides using `pow` and `exp` we also perform vector additions and multiplications by scalar. This can be potentially replaced with manually written functions similar to ones we introduced in other languages. However I don't see much benefit of doing this, especially considering that `numpy` is basically a de facto standard in the Data Science and Machine Learning community.

**UPD** However I don't have strong arguments against using `exp` and `pow` from `math` package. If there is an evidence that they perform faster than `numpy` (and apparently there is) then we should consider using them instead.
@izeigerman Thanks a lot for your prompt response!

> Besides using pow and exp we also perform vector additions and multiplications by scalar. 

Is `self.with_vectors` indicator used for that? I'm not suggesting replacing **vector** operators with manually written functions. I just suggested dropping `numpy` for fully scalar operations.

> However I don't see much benefit of doing this,

I guess ~8x speedup worth it!

> especially considering that numpy is basically a de facto standard in the Data Science and Machine Learning community.

Sure, but generated runtime Python module can be used far away from data science community 🙂 .
Hey @StrikerRUS, sorry, didn't expect you to reply so quickly :) I've edited my previous message right when you posted your reply. I've read your post carefully one more time and came to a conclusion that what you're saying makes sense. 
Great research btw 👍 
@izeigerman No problem! I'm sorry too: I read fast, type slowly and GitHub doesn't provide live updates for editions. 😃 
I'm glad you liked the idea!

Fix patch:
diff --git a/generated_code_examples/python/classification/decision_tree.py b/generated_code_examples/python/classification/decision_tree.py
index ab035740..b6746484 100644
--- a/generated_code_examples/python/classification/decision_tree.py
+++ b/generated_code_examples/python/classification/decision_tree.py
@@ -1,16 +1,15 @@
-import numpy as np
 def score(input):
     if (input[2]) <= (2.6):
-        var0 = np.asarray([1.0, 0.0, 0.0])
+        var0 = [1.0, 0.0, 0.0]
     else:
         if (input[2]) <= (4.8500004):
             if (input[3]) <= (1.6500001):
-                var0 = np.asarray([0.0, 1.0, 0.0])
+                var0 = [0.0, 1.0, 0.0]
             else:
-                var0 = np.asarray([0.0, 0.3333333333333333, 0.6666666666666666])
+                var0 = [0.0, 0.3333333333333333, 0.6666666666666666]
         else:
             if (input[3]) <= (1.75):
-                var0 = np.asarray([0.0, 0.42857142857142855, 0.5714285714285714])
+                var0 = [0.0, 0.42857142857142855, 0.5714285714285714]
             else:
-                var0 = np.asarray([0.0, 0.0, 1.0])
+                var0 = [0.0, 0.0, 1.0]
     return var0
diff --git a/generated_code_examples/python/classification/lightgbm.py b/generated_code_examples/python/classification/lightgbm.py
index ce738514..ba07cefd 100644
--- a/generated_code_examples/python/classification/lightgbm.py
+++ b/generated_code_examples/python/classification/lightgbm.py
@@ -1,4 +1,4 @@
-import numpy as np
+import math
 def score(input):
     if (input[2]) > (1.8):
         if (input[2]) > (4.250000000000001):
@@ -14,7 +14,7 @@ def score(input):
             var1 = -0.07237070828653688
     else:
         var1 = 0.12984943093573026
-    var2 = np.exp(((0) + (var0)) + (var1))
+    var2 = math.exp(((0) + (var0)) + (var1))
     if (input[2]) > (1.8):
         if (input[2]) > (4.8500000000000005):
             var3 = -1.1807342692411888
@@ -29,7 +29,7 @@ def score(input):
             var4 = 0.11960489254350348
     else:
         var4 = -0.07151978915296087
-    var5 = np.exp(((0) + (var3)) + (var4))
+    var5 = math.exp(((0) + (var3)) + (var4))
     if (input[2]) > (4.8500000000000005):
         if (input[3]) > (1.9500000000000002):
             var6 = -0.9298942558407184
@@ -50,6 +50,6 @@ def score(input):
             var7 = -0.052710589717642864
         else:
             var7 = -0.07292857712854424
-    var8 = np.exp(((0) + (var6)) + (var7))
+    var8 = math.exp(((0) + (var6)) + (var7))
     var9 = ((var2) + (var5)) + (var8)
-    return np.asarray([(var2) / (var9), (var5) / (var9), (var8) / (var9)])
+    return [(var2) / (var9), (var5) / (var9), (var8) / (var9)]
diff --git a/generated_code_examples/python/classification/linear.py b/generated_code_examples/python/classification/linear.py
index 3bedd086..aba88268 100644
--- a/generated_code_examples/python/classification/linear.py
+++ b/generated_code_examples/python/classification/linear.py
@@ -1,3 +1,2 @@
-import numpy as np
 def score(input):
-    return np.asarray([((((0.26145874358806076) + ((input[0]) * (0.4247411605356963))) + ((input[1]) * (1.3963906033045022))) + ((input[2]) * (-2.215054318516674))) + ((input[3]) * (-0.9587396176450291)), ((((1.1348839223808753) + ((input[0]) * (0.25679659769994584))) + ((input[1]) * (-1.3904789369835584))) + ((input[2]) * (0.5966830233112762))) + ((input[3]) * (-1.269002272638834)), ((((-1.216280201256021) + ((input[0]) * (-1.635776698917701))) + ((input[1]) * (-1.504063872842283))) + ((input[2]) * (2.4278359331292623))) + ((input[3]) * (2.346931069336734))])
+    return [((((0.2614587435880605) + ((input[0]) * (0.42474116053569605))) + ((input[1]) * (1.3963906033045026))) + ((input[2]) * (-2.215054318516674))) + ((input[3]) * (-0.9587396176450289)), ((((1.1348839223808307) + ((input[0]) * (0.2567965976997648))) + ((input[1]) * (-1.3904789369836008))) + ((input[2]) * (0.596683023311173))) + ((input[3]) * (-1.2690022726388828)), ((((-1.2162802012560197) + ((input[0]) * (-1.6357766989177105))) + ((input[1]) * (-1.5040638728422817))) + ((input[2]) * (2.427835933129272))) + ((input[3]) * (2.3469310693367276))]
diff --git a/generated_code_examples/python/classification/random_forest.py b/generated_code_examples/python/classification/random_forest.py
index a8677feb..5b745241 100644
--- a/generated_code_examples/python/classification/random_forest.py
+++ b/generated_code_examples/python/classification/random_forest.py
@@ -1,29 +1,29 @@
 import numpy as np
 def score(input):
     if (input[3]) <= (0.8):
-        var0 = np.asarray([1.0, 0.0, 0.0])
+        var0 = [1.0, 0.0, 0.0]
     else:
         if (input[2]) <= (4.8500004):
-            var0 = np.asarray([0.0, 0.9795918367346939, 0.02040816326530612])
+            var0 = [0.0, 0.9795918367346939, 0.02040816326530612]
         else:
             if (input[3]) <= (1.75):
                 if (input[3]) <= (1.6500001):
-                    var0 = np.asarray([0.0, 0.25, 0.75])
+                    var0 = [0.0, 0.25, 0.75]
                 else:
-                    var0 = np.asarray([0.0, 1.0, 0.0])
+                    var0 = [0.0, 1.0, 0.0]
             else:
-                var0 = np.asarray([0.0, 0.0, 1.0])
+                var0 = [0.0, 0.0, 1.0]
     if (input[3]) <= (0.8):
-        var1 = np.asarray([1.0, 0.0, 0.0])
+        var1 = [1.0, 0.0, 0.0]
     else:
         if (input[0]) <= (6.05):
             if (input[2]) <= (4.9):
-                var1 = np.asarray([0.0, 0.9032258064516129, 0.0967741935483871])
+                var1 = [0.0, 0.9032258064516129, 0.0967741935483871]
             else:
-                var1 = np.asarray([0.0, 0.0, 1.0])
+                var1 = [0.0, 0.0, 1.0]
         else:
             if (input[3]) <= (1.75):
-                var1 = np.asarray([0.0, 0.8, 0.2])
+                var1 = [0.0, 0.8, 0.2]
             else:
-                var1 = np.asarray([0.0, 0.0, 1.0])
-    return ((var0) * (0.5)) + ((var1) * (0.5))
+                var1 = [0.0, 0.0, 1.0]
+    return (np.asarray((np.asarray(var0)) * (0.5))) + (np.asarray((np.asarray(var1)) * (0.5)))
diff --git a/generated_code_examples/python/classification/svm.py b/generated_code_examples/python/classification/svm.py
index c7ec77ad..9c70abc8 100644
--- a/generated_code_examples/python/classification/svm.py
+++ b/generated_code_examples/python/classification/svm.py
@@ -1,36 +1,36 @@
-import numpy as np
+import math
 def score(input):
     var0 = (0) - (0.25)
-    var1 = np.exp((var0) * ((((np.power((5.4) - (input[0]), 2)) + (np.power((3.0) - (input[1]), 2))) + (np.power((4.5) - (input[2]), 2))) + (np.power((1.5) - (input[3]), 2))))
-    var2 = np.exp((var0) * ((((np.power((6.2) - (input[0]), 2)) + (np.power((2.2) - (input[1]), 2))) + (np.power((4.5) - (input[2]), 2))) + (np.power((1.5) - (input[3]), 2))))
-    var3 = np.exp((var0) * ((((np.power((5.0) - (input[0]), 2)) + (np.power((2.3) - (input[1]), 2))) + (np.power((3.3) - (input[2]), 2))) + (np.power((1.0) - (input[3]), 2))))
-    var4 = np.exp((var0) * ((((np.power((5.9) - (input[0]), 2)) + (np.power((3.2) - (input[1]), 2))) + (np.power((4.8) - (input[2]), 2))) + (np.power((1.8) - (input[3]), 2))))
-    var5 = np.exp((var0) * ((((np.power((5.0) - (input[0]), 2)) + (np.power((2.0) - (input[1]), 2))) + (np.power((3.5) - (input[2]), 2))) + (np.power((1.0) - (input[3]), 2))))
-    var6 = np.exp((var0) * ((((np.power((6.7) - (input[0]), 2)) + (np.power((3.0) - (input[1]), 2))) + (np.power((5.0) - (input[2]), 2))) + (np.power((1.7) - (input[3]), 2))))
-    var7 = np.exp((var0) * ((((np.power((7.0) - (input[0]), 2)) + (np.power((3.2) - (input[1]), 2))) + (np.power((4.7) - (input[2]), 2))) + (np.power((1.4) - (input[3]), 2))))
-    var8 = np.exp((var0) * ((((np.power((4.9) - (input[0]), 2)) + (np.power((2.4) - (input[1]), 2))) + (np.power((3.3) - (input[2]), 2))) + (np.power((1.0) - (input[3]), 2))))
-    var9 = np.exp((var0) * ((((np.power((6.3) - (input[0]), 2)) + (np.power((2.5) - (input[1]), 2))) + (np.power((4.9) - (input[2]), 2))) + (np.power((1.5) - (input[3]), 2))))
-    var10 = np.exp((var0) * ((((np.power((6.0) - (input[0]), 2)) + (np.power((2.7) - (input[1]), 2))) + (np.power((5.1) - (input[2]), 2))) + (np.power((1.6) - (input[3]), 2))))
-    var11 = np.exp((var0) * ((((np.power((5.7) - (input[0]), 2)) + (np.power((2.6) - (input[1]), 2))) + (np.power((3.5) - (input[2]), 2))) + (np.power((1.0) - (input[3]), 2))))
-    var12 = np.exp((var0) * ((((np.power((5.1) - (input[0]), 2)) + (np.power((3.8) - (input[1]), 2))) + (np.power((1.9) - (input[2]), 2))) + (np.power((0.4) - (input[3]), 2))))
-    var13 = np.exp((var0) * ((((np.power((4.4) - (input[0]), 2)) + (np.power((2.9) - (input[1]), 2))) + (np.power((1.4) - (input[2]), 2))) + (np.power((0.2) - (input[3]), 2))))
-    var14 = np.exp((var0) * ((((np.power((5.7) - (input[0]), 2)) + (np.power((4.4) - (input[1]), 2))) + (np.power((1.5) - (input[2]), 2))) + (np.power((0.4) - (input[3]), 2))))
-    var15 = np.exp((var0) * ((((np.power((5.8) - (input[0]), 2)) + (np.power((4.0) - (input[1]), 2))) + (np.power((1.2) - (input[2]), 2))) + (np.power((0.2) - (input[3]), 2))))
-    var16 = np.exp((var0) * ((((np.power((5.1) - (input[0]), 2)) + (np.power((3.3) - (input[1]), 2))) + (np.power((1.7) - (input[2]), 2))) + (np.power((0.5) - (input[3]), 2))))
-    var17 = np.exp((var0) * ((((np.power((5.7) - (input[0]), 2)) + (np.power((3.8) - (input[1]), 2))) + (np.power((1.7) - (input[2]), 2))) + (np.power((0.3) - (input[3]), 2))))
-    var18 = np.exp((var0) * ((((np.power((4.3) - (input[0]), 2)) + (np.power((3.0) - (input[1]), 2))) + (np.power((1.1) - (input[2]), 2))) + (np.power((0.1) - (input[3]), 2))))
-    var19 = np.exp((var0) * ((((np.power((4.5) - (input[0]), 2)) + (np.power((2.3) - (input[1]), 2))) + (np.power((1.3) - (input[2]), 2))) + (np.power((0.3) - (input[3]), 2))))
-    var20 = np.exp((var0) * ((((np.power((6.3) - (input[0]), 2)) + (np.power((2.7) - (input[1]), 2))) + (np.power((4.9) - (input[2]), 2))) + (np.power((1.8) - (input[3]), 2))))
-    var21 = np.exp((var0) * ((((np.power((6.0) - (input[0]), 2)) + (np.power((3.0) - (input[1]), 2))) + (np.power((4.8) - (input[2]), 2))) + (np.power((1.8) - (input[3]), 2))))
-    var22 = np.exp((var0) * ((((np.power((6.3) - (input[0]), 2)) + (np.power((2.8) - (input[1]), 2))) + (np.power((5.1) - (input[2]), 2))) + (np.power((1.5) - (input[3]), 2))))
-    var23 = np.exp((var0) * ((((np.power((5.8) - (input[0]), 2)) + (np.power((2.8) - (input[1]), 2))) + (np.power((5.1) - (input[2]), 2))) + (np.power((2.4) - (input[3]), 2))))
-    var24 = np.exp((var0) * ((((np.power((6.1) - (input[0]), 2)) + (np.power((3.0) - (input[1]), 2))) + (np.power((4.9) - (input[2]), 2))) + (np.power((1.8) - (input[3]), 2))))
-    var25 = np.exp((var0) * ((((np.power((7.7) - (input[0]), 2)) + (np.power((2.6) - (input[1]), 2))) + (np.power((6.9) - (input[2]), 2))) + (np.power((2.3) - (input[3]), 2))))
-    var26 = np.exp((var0) * ((((np.power((6.9) - (input[0]), 2)) + (np.power((3.1) - (input[1]), 2))) + (np.power((5.1) - (input[2]), 2))) + (np.power((2.3) - (input[3]), 2))))
-    var27 = np.exp((var0) * ((((np.power((6.3) - (input[0]), 2)) + (np.power((3.3) - (input[1]), 2))) + (np.power((6.0) - (input[2]), 2))) + (np.power((2.5) - (input[3]), 2))))
-    var28 = np.exp((var0) * ((((np.power((4.9) - (input[0]), 2)) + (np.power((2.5) - (input[1]), 2))) + (np.power((4.5) - (input[2]), 2))) + (np.power((1.7) - (input[3]), 2))))
-    var29 = np.exp((var0) * ((((np.power((6.0) - (input[0]), 2)) + (np.power((2.2) - (input[1]), 2))) + (np.power((5.0) - (input[2]), 2))) + (np.power((1.5) - (input[3]), 2))))
-    var30 = np.exp((var0) * ((((np.power((7.9) - (input[0]), 2)) + (np.power((3.8) - (input[1]), 2))) + (np.power((6.4) - (input[2]), 2))) + (np.power((2.0) - (input[3]), 2))))
-    var31 = np.exp((var0) * ((((np.power((7.2) - (input[0]), 2)) + (np.power((3.0) - (input[1]), 2))) + (np.power((5.8) - (input[2]), 2))) + (np.power((1.6) - (input[3]), 2))))
-    var32 = np.exp((var0) * ((((np.power((7.7) - (input[0]), 2)) + (np.power((3.8) - (input[1]), 2))) + (np.power((6.7) - (input[2]), 2))) + (np.power((2.2) - (input[3]), 2))))
-    return np.asarray([(((((((((((((((((((-0.08359187780790468) + ((var1) * (-0.0))) + ((var2) * (-0.0))) + ((var3) * (-0.4393498355605194))) + ((var4) * (-0.009465620856664334))) + ((var5) * (-0.16223369966927))) + ((var6) * (-0.26861888775075243))) + ((var7) * (-0.4393498355605194))) + ((var8) * (-0.4393498355605194))) + ((var9) * (-0.0))) + ((var10) * (-0.0))) + ((var11) * (-0.19673905328606292))) + ((var12) * (0.3340655283922188))) + ((var13) * (0.3435087305152051))) + ((var14) * (0.4393498355605194))) + ((var15) * (0.0))) + ((var16) * (0.28614124535416424))) + ((var17) * (0.11269159286168087))) + ((var18) * (0.0))) + ((var19) * (0.4393498355605194)), (((((((((((((((((((((-0.18563912331454907) + ((var20) * (-0.0))) + ((var21) * (-0.06014273244194299))) + ((var22) * (-0.0))) + ((var23) * (-0.031132453078851926))) + ((var24) * (-0.0))) + ((var25) * (-0.3893079321588921))) + ((var26) * (-0.06738007627290196))) + ((var27) * (-0.1225075748937126))) + ((var28) * (-0.3893079321588921))) + ((var29) * (-0.29402231709614085))) + ((var30) * (-0.3893079321588921))) + ((var31) * (-0.0))) + ((var32) * (-0.028242141062729226))) + ((var12) * (0.16634667752431267))) + ((var13) * (0.047772685163074764))) + ((var14) * (0.3893079321588921))) + ((var15) * (0.3893079321588921))) + ((var16) * (0.0))) + ((var17) * (0.0))) + ((var18) * (0.3893079321588921))) + ((var19) * (0.3893079321588921)), ((((((((((((((((((((((((0.5566649875797668) + ((var20) * (-25.563066587228416))) + ((var21) * (-38.35628154976547))) + ((var22) * (-38.35628154976547))) + ((var23) * (-0.0))) + ((var24) * (-38.35628154976547))) + ((var25) * (-0.0))) + ((var26) * (-0.0))) + ((var27) * (-0.0))) + ((var28) * (-6.2260303727828745))) + ((var29) * (-18.42781911624364))) + ((var30) * (-0.14775026537286423))) + ((var31) * (-7.169755983020096))) + ((var32) * (-0.0))) + ((var1) * (12.612328267927264))) + ((var2) * (6.565812506955159))) + ((var3) * (0.0))) + ((var4) * (38.35628154976547))) + ((var5) * (0.0))) + ((var6) * (38.35628154976547))) + ((var7) * (0.0))) + ((var8) * (0.0))) + ((var9) * (38.35628154976547))) + ((var10) * (38.35628154976547))) + ((var11) * (0.0))])
+    var1 = math.exp((var0) * ((((math.pow((5.4) - (input[0]), 2)) + (math.pow((3.0) - (input[1]), 2))) + (math.pow((4.5) - (input[2]), 2))) + (math.pow((1.5) - (input[3]), 2))))
+    var2 = math.exp((var0) * ((((math.pow((6.2) - (input[0]), 2)) + (math.pow((2.2) - (input[1]), 2))) + (math.pow((4.5) - (input[2]), 2))) + (math.pow((1.5) - (input[3]), 2))))
+    var3 = math.exp((var0) * ((((math.pow((5.0) - (input[0]), 2)) + (math.pow((2.3) - (input[1]), 2))) + (math.pow((3.3) - (input[2]), 2))) + (math.pow((1.0) - (input[3]), 2))))
+    var4 = math.exp((var0) * ((((math.pow((5.9) - (input[0]), 2)) + (math.pow((3.2) - (input[1]), 2))) + (math.pow((4.8) - (input[2]), 2))) + (math.pow((1.8) - (input[3]), 2))))
+    var5 = math.exp((var0) * ((((math.pow((5.0) - (input[0]), 2)) + (math.pow((2.0) - (input[1]), 2))) + (math.pow((3.5) - (input[2]), 2))) + (math.pow((1.0) - (input[3]), 2))))
+    var6 = math.exp((var0) * ((((math.pow((6.7) - (input[0]), 2)) + (math.pow((3.0) - (input[1]), 2))) + (math.pow((5.0) - (input[2]), 2))) + (math.pow((1.7) - (input[3]), 2))))
+    var7 = math.exp((var0) * ((((math.pow((7.0) - (input[0]), 2)) + (math.pow((3.2) - (input[1]), 2))) + (math.pow((4.7) - (input[2]), 2))) + (math.pow((1.4) - (input[3]), 2))))
+    var8 = math.exp((var0) * ((((math.pow((4.9) - (input[0]), 2)) + (math.pow((2.4) - (input[1]), 2))) + (math.pow((3.3) - (input[2]), 2))) + (math.pow((1.0) - (input[3]), 2))))
+    var9 = math.exp((var0) * ((((math.pow((6.3) - (input[0]), 2)) + (math.pow((2.5) - (input[1]), 2))) + (math.pow((4.9) - (input[2]), 2))) + (math.pow((1.5) - (input[3]), 2))))
+    var10 = math.exp((var0) * ((((math.pow((6.0) - (input[0]), 2)) + (math.pow((2.7) - (input[1]), 2))) + (math.pow((5.1) - (input[2]), 2))) + (math.pow((1.6) - (input[3]), 2))))
+    var11 = math.exp((var0) * ((((math.pow((5.7) - (input[0]), 2)) + (math.pow((2.6) - (input[1]), 2))) + (math.pow((3.5) - (input[2]), 2))) + (math.pow((1.0) - (input[3]), 2))))
+    var12 = math.exp((var0) * ((((math.pow((5.1) - (input[0]), 2)) + (math.pow((3.8) - (input[1]), 2))) + (math.pow((1.9) - (input[2]), 2))) + (math.pow((0.4) - (input[3]), 2))))
+    var13 = math.exp((var0) * ((((math.pow((4.4) - (input[0]), 2)) + (math.pow((2.9) - (input[1]), 2))) + (math.pow((1.4) - (input[2]), 2))) + (math.pow((0.2) - (input[3]), 2))))
+    var14 = math.exp((var0) * ((((math.pow((5.7) - (input[0]), 2)) + (math.pow((4.4) - (input[1]), 2))) + (math.pow((1.5) - (input[2]), 2))) + (math.pow((0.4) - (input[3]), 2))))
+    var15 = math.exp((var0) * ((((math.pow((5.8) - (input[0]), 2)) + (math.pow((4.0) - (input[1]), 2))) + (math.pow((1.2) - (input[2]), 2))) + (math.pow((0.2) - (input[3]), 2))))
+    var16 = math.exp((var0) * ((((math.pow((5.1) - (input[0]), 2)) + (math.pow((3.3) - (input[1]), 2))) + (math.pow((1.7) - (input[2]), 2))) + (math.pow((0.5) - (input[3]), 2))))
+    var17 = math.exp((var0) * ((((math.pow((5.7) - (input[0]), 2)) + (math.pow((3.8) - (input[1]), 2))) + (math.pow((1.7) - (input[2]), 2))) + (math.pow((0.3) - (input[3]), 2))))
+    var18 = math.exp((var0) * ((((math.pow((4.3) - (input[0]), 2)) + (math.pow((3.0) - (input[1]), 2))) + (math.pow((1.1) - (input[2]), 2))) + (math.pow((0.1) - (input[3]), 2))))
+    var19 = math.exp((var0) * ((((math.pow((4.5) - (input[0]), 2)) + (math.pow((2.3) - (input[1]), 2))) + (math.pow((1.3) - (input[2]), 2))) + (math.pow((0.3) - (input[3]), 2))))
+    var20 = math.exp((var0) * ((((math.pow((6.3) - (input[0]), 2)) + (math.pow((2.7) - (input[1]), 2))) + (math.pow((4.9) - (input[2]), 2))) + (math.pow((1.8) - (input[3]), 2))))
+    var21 = math.exp((var0) * ((((math.pow((6.0) - (input[0]), 2)) + (math.pow((3.0) - (input[1]), 2))) + (math.pow((4.8) - (input[2]), 2))) + (math.pow((1.8) - (input[3]), 2))))
+    var22 = math.exp((var0) * ((((math.pow((6.3) - (input[0]), 2)) + (math.pow((2.8) - (input[1]), 2))) + (math.pow((5.1) - (input[2]), 2))) + (math.pow((1.5) - (input[3]), 2))))
+    var23 = math.exp((var0) * ((((math.pow((5.8) - (input[0]), 2)) + (math.pow((2.8) - (input[1]), 2))) + (math.pow((5.1) - (input[2]), 2))) + (math.pow((2.4) - (input[3]), 2))))
+    var24 = math.exp((var0) * ((((math.pow((6.1) - (input[0]), 2)) + (math.pow((3.0) - (input[1]), 2))) + (math.pow((4.9) - (input[2]), 2))) + (math.pow((1.8) - (input[3]), 2))))
+    var25 = math.exp((var0) * ((((math.pow((7.7) - (input[0]), 2)) + (math.pow((2.6) - (input[1]), 2))) + (math.pow((6.9) - (input[2]), 2))) + (math.pow((2.3) - (input[3]), 2))))
+    var26 = math.exp((var0) * ((((math.pow((6.9) - (input[0]), 2)) + (math.pow((3.1) - (input[1]), 2))) + (math.pow((5.1) - (input[2]), 2))) + (math.pow((2.3) - (input[3]), 2))))
+    var27 = math.exp((var0) * ((((math.pow((6.3) - (input[0]), 2)) + (math.pow((3.3) - (input[1]), 2))) + (math.pow((6.0) - (input[2]), 2))) + (math.pow((2.5) - (input[3]), 2))))
+    var28 = math.exp((var0) * ((((math.pow((4.9) - (input[0]), 2)) + (math.pow((2.5) - (input[1]), 2))) + (math.pow((4.5) - (input[2]), 2))) + (math.pow((1.7) - (input[3]), 2))))
+    var29 = math.exp((var0) * ((((math.pow((6.0) - (input[0]), 2)) + (math.pow((2.2) - (input[1]), 2))) + (math.pow((5.0) - (input[2]), 2))) + (math.pow((1.5) - (input[3]), 2))))
+    var30 = math.exp((var0) * ((((math.pow((7.9) - (input[0]), 2)) + (math.pow((3.8) - (input[1]), 2))) + (math.pow((6.4) - (input[2]), 2))) + (math.pow((2.0) - (input[3]), 2))))
+    var31 = math.exp((var0) * ((((math.pow((7.2) - (input[0]), 2)) + (math.pow((3.0) - (input[1]), 2))) + (math.pow((5.8) - (input[2]), 2))) + (math.pow((1.6) - (input[3]), 2))))
+    var32 = math.exp((var0) * ((((math.pow((7.7) - (input[0]), 2)) + (math.pow((3.8) - (input[1]), 2))) + (math.pow((6.7) - (input[2]), 2))) + (math.pow((2.2) - (input[3]), 2))))
+    return [(((((((((((((((((((-0.08359187780790468) + ((var1) * (-0.0))) + ((var2) * (-0.0))) + ((var3) * (-0.4393498355605194))) + ((var4) * (-0.009465620856664334))) + ((var5) * (-0.16223369966927))) + ((var6) * (-0.26861888775075243))) + ((var7) * (-0.4393498355605194))) + ((var8) * (-0.4393498355605194))) + ((var9) * (-0.0))) + ((var10) * (-0.0))) + ((var11) * (-0.19673905328606292))) + ((var12) * (0.3340655283922188))) + ((var13) * (0.3435087305152051))) + ((var14) * (0.4393498355605194))) + ((var15) * (0.0))) + ((var16) * (0.28614124535416424))) + ((var17) * (0.11269159286168087))) + ((var18) * (0.0))) + ((var19) * (0.4393498355605194)), (((((((((((((((((((((-0.18563912331454907) + ((var20) * (-0.0))) + ((var21) * (-0.06014273244194299))) + ((var22) * (-0.0))) + ((var23) * (-0.031132453078851926))) + ((var24) * (-0.0))) + ((var25) * (-0.3893079321588921))) + ((var26) * (-0.06738007627290196))) + ((var27) * (-0.1225075748937126))) + ((var28) * (-0.3893079321588921))) + ((var29) * (-0.29402231709614085))) + ((var30) * (-0.3893079321588921))) + ((var31) * (-0.0))) + ((var32) * (-0.028242141062729226))) + ((var12) * (0.16634667752431267))) + ((var13) * (0.047772685163074764))) + ((var14) * (0.3893079321588921))) + ((var15) * (0.3893079321588921))) + ((var16) * (0.0))) + ((var17) * (0.0))) + ((var18) * (0.3893079321588921))) + ((var19) * (0.3893079321588921)), ((((((((((((((((((((((((0.5566649875797668) + ((var20) * (-25.563066587228416))) + ((var21) * (-38.35628154976547))) + ((var22) * (-38.35628154976547))) + ((var23) * (-0.0))) + ((var24) * (-38.35628154976547))) + ((var25) * (-0.0))) + ((var26) * (-0.0))) + ((var27) * (-0.0))) + ((var28) * (-6.2260303727828745))) + ((var29) * (-18.42781911624364))) + ((var30) * (-0.14775026537286423))) + ((var31) * (-7.169755983020096))) + ((var32) * (-0.0))) + ((var1) * (12.612328267927264))) + ((var2) * (6.565812506955159))) + ((var3) * (0.0))) + ((var4) * (38.35628154976547))) + ((var5) * (0.0))) + ((var6) * (38.35628154976547))) + ((var7) * (0.0))) + ((var8) * (0.0))) + ((var9) * (38.35628154976547))) + ((var10) * (38.35628154976547))) + ((var11) * (0.0))]
diff --git a/generated_code_examples/python/classification/xgboost.py b/generated_code_examples/python/classification/xgboost.py
index 9a775ba2..27df2690 100644
--- a/generated_code_examples/python/classification/xgboost.py
+++ b/generated_code_examples/python/classification/xgboost.py
@@ -1,4 +1,4 @@
-import numpy as np
+import math
 def score(input):
     if (input[2]) >= (2.5999999):
         var0 = -0.0731707439
@@ -8,7 +8,7 @@ def score(input):
         var1 = -0.0705206916
     else:
         var1 = 0.12477719
-    var2 = np.exp(((0.5) + (var0)) + (var1))
+    var2 = math.exp(((0.5) + (var0)) + (var1))
     if (input[2]) >= (2.5999999):
         if (input[2]) >= (4.85000038):
             var3 = -0.0578680299
@@ -18,12 +18,12 @@ def score(input):
         var3 = -0.0714285821
     if (input[2]) >= (2.5999999):
         if (input[2]) >= (4.85000038):
-            var4 = -0.0552999191
+            var4 = -0.0552999265
         else:
             var4 = 0.116139404
     else:
         var4 = -0.0687687024
-    var5 = np.exp(((0.5) + (var3)) + (var4))
+    var5 = math.exp(((0.5) + (var3)) + (var4))
     if (input[2]) >= (4.85000038):
         if (input[3]) >= (1.75):
             var6 = 0.142011836
@@ -36,7 +36,7 @@ def score(input):
             var6 = -0.0730659068
     if (input[2]) >= (4.85000038):
         if (input[3]) >= (1.75):
-            var7 = 0.124653712
+            var7 = 0.124653697
         else:
             var7 = 0.035562478
     else:
@@ -44,6 +44,6 @@ def score(input):
             var7 = 0.0425687581
         else:
             var7 = -0.0704230517
-    var8 = np.exp(((0.5) + (var6)) + (var7))
+    var8 = math.exp(((0.5) + (var6)) + (var7))
     var9 = ((var2) + (var5)) + (var8)
-    return np.asarray([(var2) / (var9), (var5) / (var9), (var8) / (var9)])
+    return [(var2) / (var9), (var5) / (var9), (var8) / (var9)]
diff --git a/generated_code_examples/python/regression/linear.py b/generated_code_examples/python/regression/linear.py
index 6a06d7e8..3c01e0df 100644
--- a/generated_code_examples/python/regression/linear.py
+++ b/generated_code_examples/python/regression/linear.py
@@ -1,2 +1,2 @@
 def score(input):
-    return (((((((((((((36.006810733650326) + ((input[0]) * (-0.10081655845910455))) + ((input[1]) * (0.044035569560798626))) + ((input[2]) * (0.030804434213339508))) + ((input[3]) * (2.9326736094672414))) + ((input[4]) * (-17.093360132148693))) + ((input[5]) * (3.7450682208635504))) + ((input[6]) * (0.0033774353698582506))) + ((input[7]) * (-1.4348015681660866))) + ((input[8]) * (0.2901581119428326))) + ((input[9]) * (-0.011463487956327852))) + ((input[10]) * (-0.9500012437313152))) + ((input[11]) * (0.010374330909981539))) + ((input[12]) * (-0.571389044929473))
+    return (((((((((((((36.006810733650326) + ((input[0]) * (-0.10081655845910407))) + ((input[1]) * (0.04403556956079904))) + ((input[2]) * (0.030804434213336))) + ((input[3]) * (2.9326736094672676))) + ((input[4]) * (-17.09336013214799))) + ((input[5]) * (3.74506822086355))) + ((input[6]) * (0.0033774353698562175))) + ((input[7]) * (-1.4348015681660853))) + ((input[8]) * (0.2901581119428308))) + ((input[9]) * (-0.011463487956327859))) + ((input[10]) * (-0.9500012437313143))) + ((input[11]) * (0.010374330909981067))) + ((input[12]) * (-0.5713890449294768))
diff --git a/generated_code_examples/python/regression/svm.py b/generated_code_examples/python/regression/svm.py
index dea95cf6..2fda8f60 100644
--- a/generated_code_examples/python/regression/svm.py
+++ b/generated_code_examples/python/regression/svm.py
@@ -1,4 +1,4 @@
-import numpy as np
+import math
 def score(input):
     var0 = (0) - (0.07692307692307693)
-    return ((((((((((((((((((((((((((((((((((((((((((((((((((((27.02162490523095) + ((np.exp((var0) * (((((((((((((np.power((25.9406) - (input[0]), 2)) + (np.power((0.0) - (input[1]), 2))) + (np.power((18.1) - (input[2]), 2))) + (np.power((0.0) - (input[3]), 2))) + (np.power((0.679) - (input[4]), 2))) + (np.power((5.304) - (input[5]), 2))) + (np.power((89.1) - (input[6]), 2))) + (np.power((1.6475) - (input[7]), 2))) + (np.power((24.0) - (input[8]), 2))) + (np.power((666.0) - (input[9]), 2))) + (np.power((20.2) - (input[10]), 2))) + (np.power((127.36) - (input[11]), 2))) + (np.power((26.64) - (input[12]), 2))))) * (-0.11849528386764518))) + ((np.exp((var0) * (((((((((((((np.power((6.53876) - (input[0]), 2)) + (np.power((0.0) - (input[1]), 2))) + (np.power((18.1) - (input[2]), 2))) + (np.power((1.0) - (input[3]), 2))) + (np.power((0.631) - (input[4]), 2))) + (np.power((7.016) - (input[5]), 2))) + (np.power((97.5) - (input[6]), 2))) + (np.power((1.2024) - (input[7]), 2))) + (np.power((24.0) - (input[8]), 2))) + (np.power((666.0) - (input[9]), 2))) + (np.power((20.2) - (input[10]), 2))) + (np.power((392.05) - (input[11]), 2))) + (np.power((2.96) - (input[12]), 2))))) * (1.0))) + ((np.exp((var0) * (((((((((((((np.power((22.5971) - (input[0]), 2)) + (np.power((0.0) - (input[1]), 2))) + (np.power((18.1) - (input[2]), 2))) + (np.power((0.0) - (input[3]), 2))) + (np.power((0.7) - (input[4]), 2))) + (np.power((5.0) - (input[5]), 2))) + (np.power((89.5) - (input[6]), 2))) + (np.power((1.5184) - (input[7]), 2))) + (np.power((24.0) - (input[8]), 2))) + (np.power((666.0) - (input[9]), 2))) + (np.power((20.2) - (input[10]), 2))) + (np.power((396.9) - (input[11]), 2))) + (np.power((31.99) - (input[12]), 2))))) * (-1.0))) + ((np.exp((var0) * (((((((((((((np.power((45.7461) - (input[0]), 2)) + (np.power((0.0) - (input[1]), 2))) + (np.power((18.1) - (input[2]), 2))) + (np.power((0.0) - (input[3]), 2))) + (np.power((0.693) - (input[4]), 2))) + (np.power((4.519) - (input[5]), 2))) + (np.power((100.0) - (input[6]), 2))) + (np.power((1.6582) - (input[7]), 2))) + (np.power((24.0) - (input[8]), 2))) + (np.power((666.0) - (input[9]), 2))) + (np.power((20.2) - (input[10]), 2))) + (np.power((88.27) - (input[11]), 2))) + (np.power((36.98) - (input[12]), 2))))) * (-1.0))) + ((np.exp((var0) * (((((((((((((np.power((11.8123) - (input[0]), 2)) + (np.power((0.0) - (input[1]), 2))) + (np.power((18.1) - (input[2]), 2))) + (np.power((0.0) - (input[3]), 2))) + (np.power((0.718) - (input[4]), 2))) + (np.power((6.824) - (input[5]), 2))) + (np.power((76.5) - (input[6]), 2))) + (np.power((1.794) - (input[7]), 2))) + (np.power((24.0) - (input[8]), 2))) + (np.power((666.0) - (input[9]), 2))) + (np.power((20.2) - (input[10]), 2))) + (np.power((48.45) - (input[11]), 2))) + (np.power((22.74) - (input[12]), 2))))) * (-1.0))) + ((np.exp((var0) * (((((((((((((np.power((0.08187) - (input[0]), 2)) + (np.power((0.0) - (input[1]), 2))) + (np.power((2.89) - (input[2]), 2))) + (np.power((0.0) - (input[3]), 2))) + (np.power((0.445) - (input[4]), 2))) + (np.power((7.82) - (input[5]), 2))) + (np.power((36.9) - (input[6]), 2))) + (np.power((3.4952) - (input[7]), 2))) + (np.power((2.0) - (input[8]), 2))) + (np.power((276.0) - (input[9]), 2))) + (np.power((18.0) - (input[10]), 2))) + (np.power((393.53) - (input[11]), 2))) + (np.power((3.57) - (input[12]), 2))))) * (0.2750000000382897))) + ((np.exp((var0) * (((((((((((((np.power((7.67202) - (input[0]), 2)) + (np.power((0.0) - (input[1]), 2))) + (np.power((18.1) - (input[2]), 2))) + (np.power((0.0) - (input[3]), 2))) + (np.power((0.693) - (input[4]), 2))) + (np.power((5.747) - (input[5]), 2))) + (np.power((98.9) - (input[6]), 2))) + (np.power((1.6334) - (input[7]), 2))) + (np.power((24.0) - (input[8]), 2))) + (np.power((666.0) - (input[9]), 2))) + (np.power((20.2) - (input[10]), 2))) + (np.power((393.1) - (input[11]), 2))) + (np.power((19.92) - (input[12]), 2))))) * (-1.0))) + ((np.exp((var0) * (((((((((((((np.power((1.46336) - (input[0]), 2)) + (np.power((0.0) - (input[1]), 2))) + (np.power((19.58) - (input[2]), 2))) + (np.power((0.0) - (input[3]), 2))) + (np.power((0.605) - (input[4]), 2))) + (np.power((7.489) - (input[5]), 2))) + (np.power((90.8) - (input[6]), 2))) + (np.power((1.9709) - (input[7]), 2))) + (np.power((5.0) - (input[8]), 2))) + (np.power((403.0) - (input[9]), 2))) + (np.power((14.7) - (input[10]), 2))) + (np.power((374.43) - (input[11]), 2))) + (np.power((1.73) - (input[12]), 2))))) * (1.0))) + ((np.exp((var0) * (((((((((((((np.power((20.0849) - (input[0]), 2)) + (np.power((0.0) - (input[1]), 2))) + (np.power((18.1) - (input[2]), 2))) + (np.power((0.0) - (input[3]), 2))) + (np.power((0.7) - (input[4]), 2))) + (np.power((4.368) - (input[5]), 2))) + (np.power((91.2) - (input[6]), 2))) + (np.power((1.4395) - (input[7]), 2))) + (np.power((24.0) - (input[8]), 2))) + (np.power((666.0) - (input[9]), 2))) + (np.power((20.2) - (input[10]), 2))) + (np.power((285.83) - (input[11]), 2))) + (np.power((30.63) - (input[12]), 2))))) * (-1.0))) + ((np.exp((var0) * (((((((((((((np.power((1.83377) - (input[0]), 2)) + (np.power((0.0) - (input[1]), 2))) + (np.power((19.58) - (input[2]), 2))) + (np.power((1.0) - (input[3]), 2))) + (np.power((0.605) - (input[4]), 2))) + (np.power((7.802) - (input[5]), 2))) + (np.power((98.2) - (input[6]), 2))) + (np.power((2.0407) - (input[7]), 2))) + (np.power((5.0) - (input[8]), 2))) + (np.power((403.0) - (input[9]), 2))) + (np.power((14.7) - (input[10]), 2))) + (np.power((389.61) - (input[11]), 2))) + (np.power((1.92) - (input[12]), 2))))) * (1.0))) + ((np.exp((var0) * (((((((((((((np.power((73.5341) - (input[0]), 2)) + (np.power((0.0) - (input[1]), 2))) + (np.power((18.1) - (input[2]), 2))) + (np.power((0.0) - (input[3]), 2))) + (np.power((0.679) - (input[4]), 2))) + (np.power((5.957) - (input[5]), 2))) + (np.power((100.0) - (input[6]), 2))) + (np.power((1.8026) - (input[7]), 2))) + (np.power((24.0) - (input[8]), 2))) + (np.power((666.0) - (input[9]), 2))) + (np.power((20.2) - (input[10]), 2))) + (np.power((16.45) - (input[11]), 2))) + (np.power((20.62) - (input[12]), 2))))) * (-1.0))) + ((np.exp((var0) * (((((((((((((np.power((0.33147) - (input[0]), 2)) + (np.power((0.0) - (input[1]), 2))) + (np.power((6.2) - (input[2]), 2))) + (np.power((0.0) - (input[3]), 2))) + (np.power((0.507) - (input[4]), 2))) + (np.power((8.247) - (input[5]), 2))) + (np.power((70.4) - (input[6]), 2))) + (np.power((3.6519) - (input[7]), 2))) + (np.power((8.0) - (input[8]), 2))) + (np.power((307.0) - (input[9]), 2))) + (np.power((17.4) - (input[10]), 2))) + (np.power((378.95) - (input[11]), 2))) + (np.power((3.95) - (input[12]), 2))))) * (1.0))) + ((np.exp((var0) * (((((((((((((np.power((25.0461) - (input[0]), 2)) + (np.power((0.0) - (input[1]), 2))) + (np.power((18.1) - (input[2]), 2))) + (np.power((0.0) - (input[3]), 2))) + (np.power((0.693) - (input[4]), 2))) + (np.power((5.987) - (input[5]), 2))) + (np.power((100.0) - (input[6]), 2))) + (np.power((1.5888) - (input[7]), 2))) + (np.power((24.0) - (input[8]), 2))) + (np.power((666.0) - (input[9]), 2))) + (np.power((20.2) - (input[10]), 2))) + (np.power((396.9) - (input[11]), 2))) + (np.power((26.77) - (input[12]), 2))))) * (-1.0))) + ((np.exp((var0) * (((((((((((((np.power((0.57834) - (input[0]), 2)) + (np.power((20.0) - (input[1]), 2))) + (np.power((3.97) - (input[2]), 2))) + (np.power((0.0) - (input[3]), 2))) + (np.power((0.575) - (input[4]), 2))) + (np.power((8.297) - (input[5]), 2))) + (np.power((67.0) - (input[6]), 2))) + (np.power((2.4216) - (input[7]), 2))) + (np.power((5.0) - (input[8]), 2))) + (np.power((264.0) - (input[9]), 2))) + (np.power((13.0) - (input[10]), 2))) + (np.power((384.54) - (input[11]), 2))) + (np.power((7.44) - (input[12]), 2))))) * (1.0))) + ((np.exp((var0) * (((((((((((((np.power((16.8118) - (input[0]), 2)) + (np.power((0.0) - (input[1]), 2))) + (np.power((18.1) - (input[2]), 2))) + (np.power((0.0) - (input[3]), 2))) + (np.power((0.7) - (input[4]), 2))) + (np.power((5.277) - (input[5]), 2))) + (np.power((98.1) - (input[6]), 2))) + (np.power((1.4261) - (input[7]), 2))) + (np.power((24.0) - (input[8]), 2))) + (np.power((666.0) - (input[9]), 2))) + (np.power((20.2) - (input[10]), 2))) + (np.power((396.9) - (input[11]), 2))) + (np.power((30.81) - (input[12]), 2))))) * (-1.0))) + ((np.exp((var0) * (((((((((((((np.power((0.31533) - (input[0]), 2)) + (np.power((0.0) - (input[1]), 2))) + (np.power((6.2) - (input[2]), 2))) + (np.power((0.0) - (input[3]), 2))) + (np.power((0.504) - (input[4]), 2))) + (np.power((8.266) - (input[5]), 2))) + (np.power((78.3) - (input[6]), 2))) + (np.power((2.8944) - (input[7]), 2))) + (np.power((8.0) - (input[8]), 2))) + (np.power((307.0) - (input[9]), 2))) + (np.power((17.4) - (input[10]), 2))) + (np.power((385.05) - (input[11]), 2))) + (np.power((4.14) - (input[12]), 2))))) * (1.0))) + ((np.exp((var0) * (((((((((((((np.power((67.9208) - (input[0]), 2)) + (np.power((0.0) - (input[1]), 2))) + (np.power((18.1) - (input[2]), 2))) + (np.power((0.0) - (input[3]), 2))) + (np.power((0.693) - (input[4]), 2))) + (np.power((5.683) - (input[5]), 2))) + (np.power((100.0) - (input[6]), 2))) + (np.power((1.4254) - (input[7]), 2))) + (np.power((24.0) - (input[8]), 2))) + (np.power((666.0) - (input[9]), 2))) + (np.power((20.2) - (input[10]), 2))) + (np.power((384.97) - (input[11]), 2))) + (np.power((22.98) - (input[12]), 2))))) * (-1.0))) + ((np.exp((var0) * (((((((((((((np.power((0.18337) - (input[0]), 2)) + (np.power((0.0) - (input[1]), 2))) + (np.power((27.74) - (input[2]), 2))) + (np.power((0.0) - (input[3]), 2))) + (np.power((0.609) - (input[4]), 2))) + (np.power((5.414) - (input[5]), 2))) + (np.power((98.3) - (input[6]), 2))) + (np.power((1.7554) - (input[7]), 2))) + (np.power((4.0) - (input[8]), 2))) + (np.power((711.0) - (input[9]), 2))) + (np.power((20.1) - (input[10]), 2))) + (np.power((344.05) - (input[11]), 2))) + (np.power((23.97) - (input[12]), 2))))) * (-1.0))) + ((np.exp((var0) * (((((((((((((np.power((14.3337) - (input[0]), 2)) + (np.power((0.0) - (input[1]), 2))) + (np.power((18.1) - (input[2]), 2))) + (np.power((0.0) - (input[3]), 2))) + (np.power((0.7) - (input[4]), 2))) + (np.power((4.88) - (input[5]), 2))) + (np.power((100.0) - (input[6]), 2))) + (np.power((1.5895) - (input[7]), 2))) + (np.power((24.0) - (input[8]), 2))) + (np.power((666.0) - (input[9]), 2))) + (np.power((20.2) - (input[10]), 2))) + (np.power((372.92) - (input[11]), 2))) + (np.power((30.62) - (input[12]), 2))))) * (-0.3179880503820858))) + ((np.exp((var0) * (((((((((((((np.power((0.20746) - (input[0]), 2)) + (np.power((0.0) - (input[1]), 2))) + (np.power((27.74) - (input[2]), 2))) + (np.power((0.0) - (input[3]), 2))) + (np.power((0.609) - (input[4]), 2))) + (np.power((5.093) - (input[5]), 2))) + (np.power((98.0) - (input[6]), 2))) + (np.power((1.8226) - (input[7]), 2))) + (np.power((4.0) - (input[8]), 2))) + (np.power((711.0) - (input[9]), 2))) + (np.power((20.1) - (input[10]), 2))) + (np.power((318.43) - (input[11]), 2))) + (np.power((29.68) - (input[12]), 2))))) * (-1.0))) + ((np.exp((var0) * (((((((((((((np.power((41.5292) - (input[0]), 2)) + (np.power((0.0) - (input[1]), 2))) + (np.power((18.1) - (input[2]), 2))) + (np.power((0.0) - (input[3]), 2))) + (np.power((0.693) - (input[4]), 2))) + (np.power((5.531) - (input[5]), 2))) + (np.power((85.4) - (input[6]), 2))) + (np.power((1.6074) - (input[7]), 2))) + (np.power((24.0) - (input[8]), 2))) + (np.power((666.0) - (input[9]), 2))) + (np.power((20.2) - (input[10]), 2))) + (np.power((329.46) - (input[11]), 2))) + (np.power((27.38) - (input[12]), 2))))) * (-1.0))) + ((np.exp((var0) * (((((((((((((np.power((1.51902) - (input[0]), 2)) + (np.power((0.0) - (input[1]), 2))) + (np.power((19.58) - (input[2]), 2))) + (np.power((1.0) - (input[3]), 2))) + (np.power((0.605) - (input[4]), 2))) + (np.power((8.375) - (input[5]), 2))) + (np.power((93.9) - (input[6]), 2))) + (np.power((2.162) - (input[7]), 2))) + (np.power((5.0) - (input[8]), 2))) + (np.power((403.0) - (input[9]), 2))) + (np.power((14.7) - (input[10]), 2))) + (np.power((388.45) - (input[11]), 2))) + (np.power((3.32) - (input[12]), 2))))) * (1.0))) + ((np.exp((var0) * (((((((((((((np.power((11.5779) - (input[0]), 2)) + (np.power((0.0) - (input[1]), 2))) + (np.power((18.1) - (input[2]), 2))) + (np.power((0.0) - (input[3]), 2))) + (np.power((0.7) - (input[4]), 2))) + (np.power((5.036) - (input[5]), 2))) + (np.power((97.0) - (input[6]), 2))) + (np.power((1.77) - (input[7]), 2))) + (np.power((24.0) - (input[8]), 2))) + (np.power((666.0) - (input[9]), 2))) + (np.power((20.2) - (input[10]), 2))) + (np.power((396.9) - (input[11]), 2))) + (np.power((25.68) - (input[12]), 2))))) * (-0.7698794401926943))) + ((np.exp((var0) * (((((((((((((np.power((14.2362) - (input[0]), 2)) + (np.power((0.0) - (input[1]), 2))) + (np.power((18.1) - (input[2]), 2))) + (np.power((0.0) - (input[3]), 2))) + (np.power((0.693) - (input[4]), 2))) + (np.power((6.343) - (input[5]), 2))) + (np.power((100.0) - (input[6]), 2))) + (np.power((1.5741) - (input[7]), 2))) + (np.power((24.0) - (input[8]), 2))) + (np.power((666.0) - (input[9]), 2))) + (np.power((20.2) - (input[10]), 2))) + (np.power((396.9) - (input[11]), 2))) + (np.power((20.32) - (input[12]), 2))))) * (-1.0))) + ((np.exp((var0) * (((((((((((((np.power((9.2323) - (input[0]), 2)) + (np.power((0.0) - (input[1]), 2))) + (np.power((18.1) - (input[2]), 2))) + (np.power((0.0) - (input[3]), 2))) + (np.power((0.631) - (input[4]), 2))) + (np.power((6.216) - (input[5]), 2))) + (np.power((100.0) - (input[6]), 2))) + (np.power((1.1691) - (input[7]), 2))) + (np.power((24.0) - (input[8]), 2))) + (np.power((666.0) - (input[9]), 2))) + (np.power((20.2) - (input[10]), 2))) + (np.power((366.15) - (input[11]), 2))) + (np.power((9.53) - (input[12]), 2))))) * (1.0))) + ((np.exp((var0) * (((((((((((((np.power((9.91655) - (input[0]), 2)) + (np.power((0.0) - (input[1]), 2))) + (np.power((18.1) - (input[2]), 2))) + (np.power((0.0) - (input[3]), 2))) + (np.power((0.693) - (input[4]), 2))) + (np.power((5.852) - (input[5]), 2))) + (np.power((77.8) - (input[6]), 2))) + (np.power((1.5004) - (input[7]), 2))) + (np.power((24.0) - (input[8]), 2))) + (np.power((666.0) - (input[9]), 2))) + (np.power((20.2) - (input[10]), 2))) + (np.power((338.16) - (input[11]), 2))) + (np.power((29.97) - (input[12]), 2))))) * (-1.0))) + ((np.exp((var0) * (((((((((((((np.power((22.0511) - (input[0]), 2)) + (np.power((0.0) - (input[1]), 2))) + (np.power((18.1) - (input[2]), 2))) + (np.power((0.0) - (input[3]), 2))) + (np.power((0.74) - (input[4]), 2))) + (np.power((5.818) - (input[5]), 2))) + (np.power((92.4) - (input[6]), 2))) + (np.power((1.8662) - (input[7]), 2))) + (np.power((24.0) - (input[8]), 2))) + (np.power((666.0) - (input[9]), 2))) + (np.power((20.2) - (input[10]), 2))) + (np.power((391.45) - (input[11]), 2))) + (np.power((22.11) - (input[12]), 2))))) * (-0.017541052270521836))) + ((np.exp((var0) * (((((((((((((np.power((0.61154) - (input[0]), 2)) + (np.power((20.0) - (input[1]), 2))) + (np.power((3.97) - (input[2]), 2))) + (np.power((0.0) - (input[3]), 2))) + (np.power((0.647) - (input[4]), 2))) + (np.power((8.704) - (input[5]), 2))) + (np.power((86.9) - (input[6]), 2))) + (np.power((1.801) - (input[7]), 2))) + (np.power((5.0) - (input[8]), 2))) + (np.power((264.0) - (input[9]), 2))) + (np.power((13.0) - (input[10]), 2))) + (np.power((389.7) - (input[11]), 2))) + (np.power((5.12) - (input[12]), 2))))) * (1.0))) + ((np.exp((var0) * (((((((((((((np.power((10.8342) - (input[0]), 2)) + (np.power((0.0) - (input[1]), 2))) + (np.power((18.1) - (input[2]), 2))) + (np.power((0.0) - (input[3]), 2))) + (np.power((0.679) - (input[4]), 2))) + (np.power((6.782) - (input[5]), 2))) + (np.power((90.8) - (input[6]), 2))) + (np.power((1.8195) - (input[7]), 2))) + (np.power((24.0) - (input[8]), 2))) + (np.power((666.0) - (input[9]), 2))) + (np.power((20.2) - (input[10]), 2))) + (np.power((21.57) - (input[11]), 2))) + (np.power((25.79) - (input[12]), 2))))) * (-1.0))) + ((np.exp((var0) * (((((((((((((np.power((15.8603) - (input[0]), 2)) + (np.power((0.0) - (input[1]), 2))) + (np.power((18.1) - (input[2]), 2))) + (np.power((0.0) - (input[3]), 2))) + (np.power((0.679) - (input[4]), 2))) + (np.power((5.896) - (input[5]), 2))) + (np.power((95.4) - (input[6]), 2))) + (np.power((1.9096) - (input[7]), 2))) + (np.power((24.0) - (input[8]), 2))) + (np.power((666.0) - (input[9]), 2))) + (np.power((20.2) - (input[10]), 2))) + (np.power((7.68) - (input[11]), 2))) + (np.power((24.39) - (input[12]), 2))))) * (-1.0))) + ((np.exp((var0) * (((((((((((((np.power((17.8667) - (input[0]), 2)) + (np.power((0.0) - (input[1]), 2))) + (np.power((18.1) - (input[2]), 2))) + (np.power((0.0) - (input[3]), 2))) + (np.power((0.671) - (input[4]), 2))) + (np.power((6.223) - (input[5]), 2))) + (np.power((100.0) - (input[6]), 2))) + (np.power((1.3861) - (input[7]), 2))) + (np.power((24.0) - (input[8]), 2))) + (np.power((666.0) - (input[9]), 2))) + (np.power((20.2) - (input[10]), 2))) + (np.power((393.74) - (input[11]), 2))) + (np.power((21.78) - (input[12]), 2))))) * (-0.17127153707291753))) + ((np.exp((var0) * (((((((((((((np.power((8.26725) - (input[0]), 2)) + (np.power((0.0) - (input[1]), 2))) + (np.power((18.1) - (input[2]), 2))) + (np.power((1.0) - (input[3]), 2))) + (np.power((0.668) - (input[4]), 2))) + (np.power((5.875) - (input[5]), 2))) + (np.power((89.6) - (input[6]), 2))) + (np.power((1.1296) - (input[7]), 2))) + (np.power((24.0) - (input[8]), 2))) + (np.power((666.0) - (input[9]), 2))) + (np.power((20.2) - (input[10]), 2))) + (np.power((347.88) - (input[11]), 2))) + (np.power((8.88) - (input[12]), 2))))) * (1.0))) + ((np.exp((var0) * (((((((((((((np.power((0.52693) - (input[0]), 2)) + (np.power((0.0) - (input[1]), 2))) + (np.power((6.2) - (input[2]), 2))) + (np.power((0.0) - (input[3]), 2))) + (np.power((0.504) - (input[4]), 2))) + (np.power((8.725) - (input[5]), 2))) + (np.power((83.0) - (input[6]), 2))) + (np.power((2.8944) - (input[7]), 2))) + (np.power((8.0) - (input[8]), 2))) + (np.power((307.0) - (input[9]), 2))) + (np.power((17.4) - (input[10]), 2))) + (np.power((382.0) - (input[11]), 2))) + (np.power((4.63) - (input[12]), 2))))) * (1.0))) + ((np.exp((var0) * (((((((((((((np.power((0.0351) - (input[0]), 2)) + (np.power((95.0) - (input[1]), 2))) + (np.power((2.68) - (input[2]), 2))) + (np.power((0.0) - (input[3]), 2))) + (np.power((0.4161) - (input[4]), 2))) + (np.power((7.853) - (input[5]), 2))) + (np.power((33.2) - (input[6]), 2))) + (np.power((5.118) - (input[7]), 2))) + (np.power((4.0) - (input[8]), 2))) + (np.power((224.0) - (input[9]), 2))) + (np.power((14.7) - (input[10]), 2))) + (np.power((392.78) - (input[11]), 2))) + (np.power((3.81) - (input[12]), 2))))) * (1.0))) + ((np.exp((var0) * (((((((((((((np.power((12.2472) - (input[0]), 2)) + (np.power((0.0) - (input[1]), 2))) + (np.power((18.1) - (input[2]), 2))) + (np.power((0.0) - (input[3]), 2))) + (np.power((0.584) - (input[4]), 2))) + (np.power((5.837) - (input[5]), 2))) + (np.power((59.7) - (input[6]), 2))) + (np.power((1.9976) - (input[7]), 2))) + (np.power((24.0) - (input[8]), 2))) + (np.power((666.0) - (input[9]), 2))) + (np.power((20.2) - (input[10]), 2))) + (np.power((24.65) - (input[11]), 2))) + (np.power((15.69) - (input[12]), 2))))) * (-0.31798805038208666))) + ((np.exp((var0) * (((((((((((((np.power((14.4208) - (input[0]), 2)) + (np.power((0.0) - (input[1]), 2))) + (np.power((18.1) - (input[2]), 2))) + (np.power((0.0) - (input[3]), 2))) + (np.power((0.74) - (input[4]), 2))) + (np.power((6.461) - (input[5]), 2))) + (np.power((93.3) - (input[6]), 2))) + (np.power((2.0026) - (input[7]), 2))) + (np.power((24.0) - (input[8]), 2))) + (np.power((666.0) - (input[9]), 2))) + (np.power((20.2) - (input[10]), 2))) + (np.power((27.49) - (input[11]), 2))) + (np.power((18.05) - (input[12]), 2))))) * (-0.9183413019645936))) + ((np.exp((var0) * (((((((((((((np.power((0.29819) - (input[0]), 2)) + (np.power((0.0) - (input[1]), 2))) + (np.power((6.2) - (input[2]), 2))) + (np.power((0.0) - (input[3]), 2))) + (np.power((0.504) - (input[4]), 2))) + (np.power((7.686) - (input[5]), 2))) + (np.power((17.0) - (input[6]), 2))) + (np.power((3.3751) - (input[7]), 2))) + (np.power((8.0) - (input[8]), 2))) + (np.power((307.0) - (input[9]), 2))) + (np.power((17.4) - (input[10]), 2))) + (np.power((377.51) - (input[11]), 2))) + (np.power((3.92) - (input[12]), 2))))) * (1.0))) + ((np.exp((var0) * (((((((((((((np.power((38.3518) - (input[0]), 2)) + (np.power((0.0) - (input[1]), 2))) + (np.power((18.1) - (input[2]), 2))) + (np.power((0.0) - (input[3]), 2))) + (np.power((0.693) - (input[4]), 2))) + (np.power((5.453) - (input[5]), 2))) + (np.power((100.0) - (input[6]), 2))) + (np.power((1.4896) - (input[7]), 2))) + (np.power((24.0) - (input[8]), 2))) + (np.power((666.0) - (input[9]), 2))) + (np.power((20.2) - (input[10]), 2))) + (np.power((396.9) - (input[11]), 2))) + (np.power((30.59) - (input[12]), 2))))) * (-1.0))) + ((np.exp((var0) * (((((((((((((np.power((0.06129) - (input[0]), 2)) + (np.power((20.0) - (input[1]), 2))) + (np.power((3.33) - (input[2]), 2))) + (np.power((1.0) - (input[3]), 2))) + (np.power((0.4429) - (input[4]), 2))) + (np.power((7.645) - (input[5]), 2))) + (np.power((49.7) - (input[6]), 2))) + (np.power((5.2119) - (input[7]), 2))) + (np.power((5.0) - (input[8]), 2))) + (np.power((216.0) - (input[9]), 2))) + (np.power((14.9) - (input[10]), 2))) + (np.power((377.07) - (input[11]), 2))) + (np.power((3.01) - (input[12]), 2))))) * (1.0))) + ((np.exp((var0) * (((((((((((((np.power((88.9762) - (input[0]), 2)) + (np.power((0.0) - (input[1]), 2))) + (np.power((18.1) - (input[2]), 2))) + (np.power((0.0) - (input[3]), 2))) + (np.power((0.671) - (input[4]), 2))) + (np.power((6.968) - (input[5]), 2))) + (np.power((91.9) - (input[6]), 2))) + (np.power((1.4165) - (input[7]), 2))) + (np.power((24.0) - (input[8]), 2))) + (np.power((666.0) - (input[9]), 2))) + (np.power((20.2) - (input[10]), 2))) + (np.power((396.9) - (input[11]), 2))) + (np.power((17.21) - (input[12]), 2))))) * (-0.11849528386764341))) + ((np.exp((var0) * (((((((((((((np.power((0.05602) - (input[0]), 2)) + (np.power((0.0) - (input[1]), 2))) + (np.power((2.46) - (input[2]), 2))) + (np.power((0.0) - (input[3]), 2))) + (np.power((0.488) - (input[4]), 2))) + (np.power((7.831) - (input[5]), 2))) + (np.power((53.6) - (input[6]), 2))) + (np.power((3.1992) - (input[7]), 2))) + (np.power((3.0) - (input[8]), 2))) + (np.power((193.0) - (input[9]), 2))) + (np.power((17.8) - (input[10]), 2))) + (np.power((392.63) - (input[11]), 2))) + (np.power((4.45) - (input[12]), 2))))) * (1.0))) + ((np.exp((var0) * (((((((((((((np.power((0.01501) - (input[0]), 2)) + (np.power((90.0) - (input[1]), 2))) + (np.power((1.21) - (input[2]), 2))) + (np.power((1.0) - (input[3]), 2))) + (np.power((0.401) - (input[4]), 2))) + (np.power((7.923) - (input[5]), 2))) + (np.power((24.8) - (input[6]), 2))) + (np.power((5.885) - (input[7]), 2))) + (np.power((1.0) - (input[8]), 2))) + (np.power((198.0) - (input[9]), 2))) + (np.power((13.6) - (input[10]), 2))) + (np.power((395.52) - (input[11]), 2))) + (np.power((3.16) - (input[12]), 2))))) * (1.0))) + ((np.exp((var0) * (((((((((((((np.power((0.02009) - (input[0]), 2)) + (np.power((95.0) - (input[1]), 2))) + (np.power((2.68) - (input[2]), 2))) + (np.power((0.0) - (input[3]), 2))) + (np.power((0.4161) - (input[4]), 2))) + (np.power((8.034) - (input[5]), 2))) + (np.power((31.9) - (input[6]), 2))) + (np.power((5.118) - (input[7]), 2))) + (np.power((4.0) - (input[8]), 2))) + (np.power((224.0) - (input[9]), 2))) + (np.power((14.7) - (input[10]), 2))) + (np.power((390.55) - (input[11]), 2))) + (np.power((2.88) - (input[12]), 2))))) * (1.0))) + ((np.exp((var0) * (((((((((((((np.power((15.1772) - (input[0]), 2)) + (np.power((0.0) - (input[1]), 2))) + (np.power((18.1) - (input[2]), 2))) + (np.power((0.0) - (input[3]), 2))) + (np.power((0.74) - (input[4]), 2))) + (np.power((6.152) - (input[5]), 2))) + (np.power((100.0) - (input[6]), 2))) + (np.power((1.9142) - (input[7]), 2))) + (np.power((24.0) - (input[8]), 2))) + (np.power((666.0) - (input[9]), 2))) + (np.power((20.2) - (input[10]), 2))) + (np.power((9.32) - (input[11]), 2))) + (np.power((26.45) - (input[12]), 2))))) * (-1.0))) + ((np.exp((var0) * (((((((((((((np.power((18.0846) - (input[0]), 2)) + (np.power((0.0) - (input[1]), 2))) + (np.power((18.1) - (input[2]), 2))) + (np.power((0.0) - (input[3]), 2))) + (np.power((0.679) - (input[4]), 2))) + (np.power((6.434) - (input[5]), 2))) + (np.power((100.0) - (input[6]), 2))) + (np.power((1.8347) - (input[7]), 2))) + (np.power((24.0) - (input[8]), 2))) + (np.power((666.0) - (input[9]), 2))) + (np.power((20.2) - (input[10]), 2))) + (np.power((27.25) - (input[11]), 2))) + (np.power((29.05) - (input[12]), 2))))) * (-1.0))) + ((np.exp((var0) * (((((((((((((np.power((0.01381) - (input[0]), 2)) + (np.power((80.0) - (input[1]), 2))) + (np.power((0.46) - (input[2]), 2))) + (np.power((0.0) - (input[3]), 2))) + (np.power((0.422) - (input[4]), 2))) + (np.power((7.875) - (input[5]), 2))) + (np.power((32.0) - (input[6]), 2))) + (np.power((5.6484) - (input[7]), 2))) + (np.power((4.0) - (input[8]), 2))) + (np.power((255.0) - (input[9]), 2))) + (np.power((14.4) - (input[10]), 2))) + (np.power((394.23) - (input[11]), 2))) + (np.power((2.97) - (input[12]), 2))))) * (1.0))) + ((np.exp((var0) * (((((((((((((np.power((5.66998) - (input[0]), 2)) + (np.power((0.0) - (input[1]), 2))) + (np.power((18.1) - (input[2]), 2))) + (np.power((1.0) - (input[3]), 2))) + (np.power((0.631) - (input[4]), 2))) + (np.power((6.683) - (input[5]), 2))) + (np.power((96.8) - (input[6]), 2))) + (np.power((1.3567) - (input[7]), 2))) + (np.power((24.0) - (input[8]), 2))) + (np.power((666.0) - (input[9]), 2))) + (np.power((20.2) - (input[10]), 2))) + (np.power((375.33) - (input[11]), 2))) + (np.power((3.73) - (input[12]), 2))))) * (1.0))) + ((np.exp((var0) * (((((((((((((np.power((0.01538) - (input[0]), 2)) + (np.power((90.0) - (input[1]), 2))) + (np.power((3.75) - (input[2]), 2))) + (np.power((0.0) - (input[3]), 2))) + (np.power((0.394) - (input[4]), 2))) + (np.power((7.454) - (input[5]), 2))) + (np.power((34.2) - (input[6]), 2))) + (np.power((6.3361) - (input[7]), 2))) + (np.power((3.0) - (input[8]), 2))) + (np.power((244.0) - (input[9]), 2))) + (np.power((15.9) - (input[10]), 2))) + (np.power((386.34) - (input[11]), 2))) + (np.power((3.11) - (input[12]), 2))))) * (0.47499999996189857))) + ((np.exp((var0) * (((((((((((((np.power((4.89822) - (input[0]), 2)) + (np.power((0.0) - (input[1]), 2))) + (np.power((18.1) - (input[2]), 2))) + (np.power((0.0) - (input[3]), 2))) + (np.power((0.631) - (input[4]), 2))) + (np.power((4.97) - (input[5]), 2))) + (np.power((100.0) - (input[6]), 2))) + (np.power((1.3325) - (input[7]), 2))) + (np.power((24.0) - (input[8]), 2))) + (np.power((666.0) - (input[9]), 2))) + (np.power((20.2) - (input[10]), 2))) + (np.power((375.52) - (input[11]), 2))) + (np.power((3.26) - (input[12]), 2))))) * (1.0))) + ((np.exp((var0) * (((((((((((((np.power((2.01019) - (input[0]), 2)) + (np.power((0.0) - (input[1]), 2))) + (np.power((19.58) - (input[2]), 2))) + (np.power((0.0) - (input[3]), 2))) + (np.power((0.605) - (input[4]), 2))) + (np.power((7.929) - (input[5]), 2))) + (np.power((96.2) - (input[6]), 2))) + (np.power((2.0459) - (input[7]), 2))) + (np.power((5.0) - (input[8]), 2))) + (np.power((403.0) - (input[9]), 2))) + (np.power((14.7) - (input[10]), 2))) + (np.power((369.3) - (input[11]), 2))) + (np.power((3.7) - (input[12]), 2))))) * (1.0))) + ((np.exp((var0) * (((((((((((((np.power((0.52014) - (input[0]), 2)) + (np.power((20.0) - (input[1]), 2))) + (np.power((3.97) - (input[2]), 2))) + (np.power((0.0) - (input[3]), 2))) + (np.power((0.647) - (input[4]), 2))) + (np.power((8.398) - (input[5]), 2))) + (np.power((91.5) - (input[6]), 2))) + (np.power((2.2885) - (input[7]), 2))) + (np.power((5.0) - (input[8]), 2))) + (np.power((264.0) - (input[9]), 2))) + (np.power((13.0) - (input[10]), 2))) + (np.power((386.86) - (input[11]), 2))) + (np.power((5.91) - (input[12]), 2))))) * (1.0))) + ((np.exp((var0) * (((((((((((((np.power((9.33889) - (input[0]), 2)) + (np.power((0.0) - (input[1]), 2))) + (np.power((18.1) - (input[2]), 2))) + (np.power((0.0) - (input[3]), 2))) + (np.power((0.679) - (input[4]), 2))) + (np.power((6.38) - (input[5]), 2))) + (np.power((95.6) - (input[6]), 2))) + (np.power((1.9682) - (input[7]), 2))) + (np.power((24.0) - (input[8]), 2))) + (np.power((666.0) - (input[9]), 2))) + (np.power((20.2) - (input[10]), 2))) + (np.power((60.72) - (input[11]), 2))) + (np.power((24.08) - (input[12]), 2))))) * (-1.0))
+    return ((((((((((((((((((((((((((((((((((((((((((((((((((((27.02162490523095) + ((math.exp((var0) * (((((((((((((math.pow((25.9406) - (input[0]), 2)) + (math.pow((0.0) - (input[1]), 2))) + (math.pow((18.1) - (input[2]), 2))) + (math.pow((0.0) - (input[3]), 2))) + (math.pow((0.679) - (input[4]), 2))) + (math.pow((5.304) - (input[5]), 2))) + (math.pow((89.1) - (input[6]), 2))) + (math.pow((1.6475) - (input[7]), 2))) + (math.pow((24.0) - (input[8]), 2))) + (math.pow((666.0) - (input[9]), 2))) + (math.pow((20.2) - (input[10]), 2))) + (math.pow((127.36) - (input[11]), 2))) + (math.pow((26.64) - (input[12]), 2))))) * (-0.11849528386764518))) + ((math.exp((var0) * (((((((((((((math.pow((6.53876) - (input[0]), 2)) + (math.pow((0.0) - (input[1]), 2))) + (math.pow((18.1) - (input[2]), 2))) + (math.pow((1.0) - (input[3]), 2))) + (math.pow((0.631) - (input[4]), 2))) + (math.pow((7.016) - (input[5]), 2))) + (math.pow((97.5) - (input[6]), 2))) + (math.pow((1.2024) - (input[7]), 2))) + (math.pow((24.0) - (input[8]), 2))) + (math.pow((666.0) - (input[9]), 2))) + (math.pow((20.2) - (input[10]), 2))) + (math.pow((392.05) - (input[11]), 2))) + (math.pow((2.96) - (input[12]), 2))))) * (1.0))) + ((math.exp((var0) * (((((((((((((math.pow((22.5971) - (input[0]), 2)) + (math.pow((0.0) - (input[1]), 2))) + (math.pow((18.1) - (input[2]), 2))) + (math.pow((0.0) - (input[3]), 2))) + (math.pow((0.7) - (input[4]), 2))) + (math.pow((5.0) - (input[5]), 2))) + (math.pow((89.5) - (input[6]), 2))) + (math.pow((1.5184) - (input[7]), 2))) + (math.pow((24.0) - (input[8]), 2))) + (math.pow((666.0) - (input[9]), 2))) + (math.pow((20.2) - (input[10]), 2))) + (math.pow((396.9) - (input[11]), 2))) + (math.pow((31.99) - (input[12]), 2))))) * (-1.0))) + ((math.exp((var0) * (((((((((((((math.pow((45.7461) - (input[0]), 2)) + (math.pow((0.0) - (input[1]), 2))) + (math.pow((18.1) - (input[2]), 2))) + (math.pow((0.0) - (input[3]), 2))) + (math.pow((0.693) - (input[4]), 2))) + (math.pow((4.519) - (input[5]), 2))) + (math.pow((100.0) - (input[6]), 2))) + (math.pow((1.6582) - (input[7]), 2))) + (math.pow((24.0) - (input[8]), 2))) + (math.pow((666.0) - (input[9]), 2))) + (math.pow((20.2) - (input[10]), 2))) + (math.pow((88.27) - (input[11]), 2))) + (math.pow((36.98) - (input[12]), 2))))) * (-1.0))) + ((math.exp((var0) * (((((((((((((math.pow((11.8123) - (input[0]), 2)) + (math.pow((0.0) - (input[1]), 2))) + (math.pow((18.1) - (input[2]), 2))) + (math.pow((0.0) - (input[3]), 2))) + (math.pow((0.718) - (input[4]), 2))) + (math.pow((6.824) - (input[5]), 2))) + (math.pow((76.5) - (input[6]), 2))) + (math.pow((1.794) - (input[7]), 2))) + (math.pow((24.0) - (input[8]), 2))) + (math.pow((666.0) - (input[9]), 2))) + (math.pow((20.2) - (input[10]), 2))) + (math.pow((48.45) - (input[11]), 2))) + (math.pow((22.74) - (input[12]), 2))))) * (-1.0))) + ((math.exp((var0) * (((((((((((((math.pow((0.08187) - (input[0]), 2)) + (math.pow((0.0) - (input[1]), 2))) + (math.pow((2.89) - (input[2]), 2))) + (math.pow((0.0) - (input[3]), 2))) + (math.pow((0.445) - (input[4]), 2))) + (math.pow((7.82) - (input[5]), 2))) + (math.pow((36.9) - (input[6]), 2))) + (math.pow((3.4952) - (input[7]), 2))) + (math.pow((2.0) - (input[8]), 2))) + (math.pow((276.0) - (input[9]), 2))) + (math.pow((18.0) - (input[10]), 2))) + (math.pow((393.53) - (input[11]), 2))) + (math.pow((3.57) - (input[12]), 2))))) * (0.2750000000382897))) + ((math.exp((var0) * (((((((((((((math.pow((7.67202) - (input[0]), 2)) + (math.pow((0.0) - (input[1]), 2))) + (math.pow((18.1) - (input[2]), 2))) + (math.pow((0.0) - (input[3]), 2))) + (math.pow((0.693) - (input[4]), 2))) + (math.pow((5.747) - (input[5]), 2))) + (math.pow((98.9) - (input[6]), 2))) + (math.pow((1.6334) - (input[7]), 2))) + (math.pow((24.0) - (input[8]), 2))) + (math.pow((666.0) - (input[9]), 2))) + (math.pow((20.2) - (input[10]), 2))) + (math.pow((393.1) - (input[11]), 2))) + (math.pow((19.92) - (input[12]), 2))))) * (-1.0))) + ((math.exp((var0) * (((((((((((((math.pow((1.46336) - (input[0]), 2)) + (math.pow((0.0) - (input[1]), 2))) + (math.pow((19.58) - (input[2]), 2))) + (math.pow((0.0) - (input[3]), 2))) + (math.pow((0.605) - (input[4]), 2))) + (math.pow((7.489) - (input[5]), 2))) + (math.pow((90.8) - (input[6]), 2))) + (math.pow((1.9709) - (input[7]), 2))) + (math.pow((5.0) - (input[8]), 2))) + (math.pow((403.0) - (input[9]), 2))) + (math.pow((14.7) - (input[10]), 2))) + (math.pow((374.43) - (input[11]), 2))) + (math.pow((1.73) - (input[12]), 2))))) * (1.0))) + ((math.exp((var0) * (((((((((((((math.pow((20.0849) - (input[0]), 2)) + (math.pow((0.0) - (input[1]), 2))) + (math.pow((18.1) - (input[2]), 2))) + (math.pow((0.0) - (input[3]), 2))) + (math.pow((0.7) - (input[4]), 2))) + (math.pow((4.368) - (input[5]), 2))) + (math.pow((91.2) - (input[6]), 2))) + (math.pow((1.4395) - (input[7]), 2))) + (math.pow((24.0) - (input[8]), 2))) + (math.pow((666.0) - (input[9]), 2))) + (math.pow((20.2) - (input[10]), 2))) + (math.pow((285.83) - (input[11]), 2))) + (math.pow((30.63) - (input[12]), 2))))) * (-1.0))) + ((math.exp((var0) * (((((((((((((math.pow((1.83377) - (input[0]), 2)) + (math.pow((0.0) - (input[1]), 2))) + (math.pow((19.58) - (input[2]), 2))) + (math.pow((1.0) - (input[3]), 2))) + (math.pow((0.605) - (input[4]), 2))) + (math.pow((7.802) - (input[5]), 2))) + (math.pow((98.2) - (input[6]), 2))) + (math.pow((2.0407) - (input[7]), 2))) + (math.pow((5.0) - (input[8]), 2))) + (math.pow((403.0) - (input[9]), 2))) + (math.pow((14.7) - (input[10]), 2))) + (math.pow((389.61) - (input[11]), 2))) + (math.pow((1.92) - (input[12]), 2))))) * (1.0))) + ((math.exp((var0) * (((((((((((((math.pow((73.5341) - (input[0]), 2)) + (math.pow((0.0) - (input[1]), 2))) + (math.pow((18.1) - (input[2]), 2))) + (math.pow((0.0) - (input[3]), 2))) + (math.pow((0.679) - (input[4]), 2))) + (math.pow((5.957) - (input[5]), 2))) + (math.pow((100.0) - (input[6]), 2))) + (math.pow((1.8026) - (input[7]), 2))) + (math.pow((24.0) - (input[8]), 2))) + (math.pow((666.0) - (input[9]), 2))) + (math.pow((20.2) - (input[10]), 2))) + (math.pow((16.45) - (input[11]), 2))) + (math.pow((20.62) - (input[12]), 2))))) * (-1.0))) + ((math.exp((var0) * (((((((((((((math.pow((0.33147) - (input[0]), 2)) + (math.pow((0.0) - (input[1]), 2))) + (math.pow((6.2) - (input[2]), 2))) + (math.pow((0.0) - (input[3]), 2))) + (math.pow((0.507) - (input[4]), 2))) + (math.pow((8.247) - (input[5]), 2))) + (math.pow((70.4) - (input[6]), 2))) + (math.pow((3.6519) - (input[7]), 2))) + (math.pow((8.0) - (input[8]), 2))) + (math.pow((307.0) - (input[9]), 2))) + (math.pow((17.4) - (input[10]), 2))) + (math.pow((378.95) - (input[11]), 2))) + (math.pow((3.95) - (input[12]), 2))))) * (1.0))) + ((math.exp((var0) * (((((((((((((math.pow((25.0461) - (input[0]), 2)) + (math.pow((0.0) - (input[1]), 2))) + (math.pow((18.1) - (input[2]), 2))) + (math.pow((0.0) - (input[3]), 2))) + (math.pow((0.693) - (input[4]), 2))) + (math.pow((5.987) - (input[5]), 2))) + (math.pow((100.0) - (input[6]), 2))) + (math.pow((1.5888) - (input[7]), 2))) + (math.pow((24.0) - (input[8]), 2))) + (math.pow((666.0) - (input[9]), 2))) + (math.pow((20.2) - (input[10]), 2))) + (math.pow((396.9) - (input[11]), 2))) + (math.pow((26.77) - (input[12]), 2))))) * (-1.0))) + ((math.exp((var0) * (((((((((((((math.pow((0.57834) - (input[0]), 2)) + (math.pow((20.0) - (input[1]), 2))) + (math.pow((3.97) - (input[2]), 2))) + (math.pow((0.0) - (input[3]), 2))) + (math.pow((0.575) - (input[4]), 2))) + (math.pow((8.297) - (input[5]), 2))) + (math.pow((67.0) - (input[6]), 2))) + (math.pow((2.4216) - (input[7]), 2))) + (math.pow((5.0) - (input[8]), 2))) + (math.pow((264.0) - (input[9]), 2))) + (math.pow((13.0) - (input[10]), 2))) + (math.pow((384.54) - (input[11]), 2))) + (math.pow((7.44) - (input[12]), 2))))) * (1.0))) + ((math.exp((var0) * (((((((((((((math.pow((16.8118) - (input[0]), 2)) + (math.pow((0.0) - (input[1]), 2))) + (math.pow((18.1) - (input[2]), 2))) + (math.pow((0.0) - (input[3]), 2))) + (math.pow((0.7) - (input[4]), 2))) + (math.pow((5.277) - (input[5]), 2))) + (math.pow((98.1) - (input[6]), 2))) + (math.pow((1.4261) - (input[7]), 2))) + (math.pow((24.0) - (input[8]), 2))) + (math.pow((666.0) - (input[9]), 2))) + (math.pow((20.2) - (input[10]), 2))) + (math.pow((396.9) - (input[11]), 2))) + (math.pow((30.81) - (input[12]), 2))))) * (-1.0))) + ((math.exp((var0) * (((((((((((((math.pow((0.31533) - (input[0]), 2)) + (math.pow((0.0) - (input[1]), 2))) + (math.pow((6.2) - (input[2]), 2))) + (math.pow((0.0) - (input[3]), 2))) + (math.pow((0.504) - (input[4]), 2))) + (math.pow((8.266) - (input[5]), 2))) + (math.pow((78.3) - (input[6]), 2))) + (math.pow((2.8944) - (input[7]), 2))) + (math.pow((8.0) - (input[8]), 2))) + (math.pow((307.0) - (input[9]), 2))) + (math.pow((17.4) - (input[10]), 2))) + (math.pow((385.05) - (input[11]), 2))) + (math.pow((4.14) - (input[12]), 2))))) * (1.0))) + ((math.exp((var0) * (((((((((((((math.pow((67.9208) - (input[0]), 2)) + (math.pow((0.0) - (input[1]), 2))) + (math.pow((18.1) - (input[2]), 2))) + (math.pow((0.0) - (input[3]), 2))) + (math.pow((0.693) - (input[4]), 2))) + (math.pow((5.683) - (input[5]), 2))) + (math.pow((100.0) - (input[6]), 2))) + (math.pow((1.4254) - (input[7]), 2))) + (math.pow((24.0) - (input[8]), 2))) + (math.pow((666.0) - (input[9]), 2))) + (math.pow((20.2) - (input[10]), 2))) + (math.pow((384.97) - (input[11]), 2))) + (math.pow((22.98) - (input[12]), 2))))) * (-1.0))) + ((math.exp((var0) * (((((((((((((math.pow((0.18337) - (input[0]), 2)) + (math.pow((0.0) - (input[1]), 2))) + (math.pow((27.74) - (input[2]), 2))) + (math.pow((0.0) - (input[3]), 2))) + (math.pow((0.609) - (input[4]), 2))) + (math.pow((5.414) - (input[5]), 2))) + (math.pow((98.3) - (input[6]), 2))) + (math.pow((1.7554) - (input[7]), 2))) + (math.pow((4.0) - (input[8]), 2))) + (math.pow((711.0) - (input[9]), 2))) + (math.pow((20.1) - (input[10]), 2))) + (math.pow((344.05) - (input[11]), 2))) + (math.pow((23.97) - (input[12]), 2))))) * (-1.0))) + ((math.exp((var0) * (((((((((((((math.pow((14.3337) - (input[0]), 2)) + (math.pow((0.0) - (input[1]), 2))) + (math.pow((18.1) - (input[2]), 2))) + (math.pow((0.0) - (input[3]), 2))) + (math.pow((0.7) - (input[4]), 2))) + (math.pow((4.88) - (input[5]), 2))) + (math.pow((100.0) - (input[6]), 2))) + (math.pow((1.5895) - (input[7]), 2))) + (math.pow((24.0) - (input[8]), 2))) + (math.pow((666.0) - (input[9]), 2))) + (math.pow((20.2) - (input[10]), 2))) + (math.pow((372.92) - (input[11]), 2))) + (math.pow((30.62) - (input[12]), 2))))) * (-0.3179880503820858))) + ((math.exp((var0) * (((((((((((((math.pow((0.20746) - (input[0]), 2)) + (math.pow((0.0) - (input[1]), 2))) + (math.pow((27.74) - (input[2]), 2))) + (math.pow((0.0) - (input[3]), 2))) + (math.pow((0.609) - (input[4]), 2))) + (math.pow((5.093) - (input[5]), 2))) + (math.pow((98.0) - (input[6]), 2))) + (math.pow((1.8226) - (input[7]), 2))) + (math.pow((4.0) - (input[8]), 2))) + (math.pow((711.0) - (input[9]), 2))) + (math.pow((20.1) - (input[10]), 2))) + (math.pow((318.43) - (input[11]), 2))) + (math.pow((29.68) - (input[12]), 2))))) * (-1.0))) + ((math.exp((var0) * (((((((((((((math.pow((41.5292) - (input[0]), 2)) + (math.pow((0.0) - (input[1]), 2))) + (math.pow((18.1) - (input[2]), 2))) + (math.pow((0.0) - (input[3]), 2))) + (math.pow((0.693) - (input[4]), 2))) + (math.pow((5.531) - (input[5]), 2))) + (math.pow((85.4) - (input[6]), 2))) + (math.pow((1.6074) - (input[7]), 2))) + (math.pow((24.0) - (input[8]), 2))) + (math.pow((666.0) - (input[9]), 2))) + (math.pow((20.2) - (input[10]), 2))) + (math.pow((329.46) - (input[11]), 2))) + (math.pow((27.38) - (input[12]), 2))))) * (-1.0))) + ((math.exp((var0) * (((((((((((((math.pow((1.51902) - (input[0]), 2)) + (math.pow((0.0) - (input[1]), 2))) + (math.pow((19.58) - (input[2]), 2))) + (math.pow((1.0) - (input[3]), 2))) + (math.pow((0.605) - (input[4]), 2))) + (math.pow((8.375) - (input[5]), 2))) + (math.pow((93.9) - (input[6]), 2))) + (math.pow((2.162) - (input[7]), 2))) + (math.pow((5.0) - (input[8]), 2))) + (math.pow((403.0) - (input[9]), 2))) + (math.pow((14.7) - (input[10]), 2))) + (math.pow((388.45) - (input[11]), 2))) + (math.pow((3.32) - (input[12]), 2))))) * (1.0))) + ((math.exp((var0) * (((((((((((((math.pow((11.5779) - (input[0]), 2)) + (math.pow((0.0) - (input[1]), 2))) + (math.pow((18.1) - (input[2]), 2))) + (math.pow((0.0) - (input[3]), 2))) + (math.pow((0.7) - (input[4]), 2))) + (math.pow((5.036) - (input[5]), 2))) + (math.pow((97.0) - (input[6]), 2))) + (math.pow((1.77) - (input[7]), 2))) + (math.pow((24.0) - (input[8]), 2))) + (math.pow((666.0) - (input[9]), 2))) + (math.pow((20.2) - (input[10]), 2))) + (math.pow((396.9) - (input[11]), 2))) + (math.pow((25.68) - (input[12]), 2))))) * (-0.7698794401926943))) + ((math.exp((var0) * (((((((((((((math.pow((14.2362) - (input[0]), 2)) + (math.pow((0.0) - (input[1]), 2))) + (math.pow((18.1) - (input[2]), 2))) + (math.pow((0.0) - (input[3]), 2))) + (math.pow((0.693) - (input[4]), 2))) + (math.pow((6.343) - (input[5]), 2))) + (math.pow((100.0) - (input[6]), 2))) + (math.pow((1.5741) - (input[7]), 2))) + (math.pow((24.0) - (input[8]), 2))) + (math.pow((666.0) - (input[9]), 2))) + (math.pow((20.2) - (input[10]), 2))) + (math.pow((396.9) - (input[11]), 2))) + (math.pow((20.32) - (input[12]), 2))))) * (-1.0))) + ((math.exp((var0) * (((((((((((((math.pow((9.2323) - (input[0]), 2)) + (math.pow((0.0) - (input[1]), 2))) + (math.pow((18.1) - (input[2]), 2))) + (math.pow((0.0) - (input[3]), 2))) + (math.pow((0.631) - (input[4]), 2))) + (math.pow((6.216) - (input[5]), 2))) + (math.pow((100.0) - (input[6]), 2))) + (math.pow((1.1691) - (input[7]), 2))) + (math.pow((24.0) - (input[8]), 2))) + (math.pow((666.0) - (input[9]), 2))) + (math.pow((20.2) - (input[10]), 2))) + (math.pow((366.15) - (input[11]), 2))) + (math.pow((9.53) - (input[12]), 2))))) * (1.0))) + ((math.exp((var0) * (((((((((((((math.pow((9.91655) - (input[0]), 2)) + (math.pow((0.0) - (input[1]), 2))) + (math.pow((18.1) - (input[2]), 2))) + (math.pow((0.0) - (input[3]), 2))) + (math.pow((0.693) - (input[4]), 2))) + (math.pow((5.852) - (input[5]), 2))) + (math.pow((77.8) - (input[6]), 2))) + (math.pow((1.5004) - (input[7]), 2))) + (math.pow((24.0) - (input[8]), 2))) + (math.pow((666.0) - (input[9]), 2))) + (math.pow((20.2) - (input[10]), 2))) + (math.pow((338.16) - (input[11]), 2))) + (math.pow((29.97) - (input[12]), 2))))) * (-1.0))) + ((math.exp((var0) * (((((((((((((math.pow((22.0511) - (input[0]), 2)) + (math.pow((0.0) - (input[1]), 2))) + (math.pow((18.1) - (input[2]), 2))) + (math.pow((0.0) - (input[3]), 2))) + (math.pow((0.74) - (input[4]), 2))) + (math.pow((5.818) - (input[5]), 2))) + (math.pow((92.4) - (input[6]), 2))) + (math.pow((1.8662) - (input[7]), 2))) + (math.pow((24.0) - (input[8]), 2))) + (math.pow((666.0) - (input[9]), 2))) + (math.pow((20.2) - (input[10]), 2))) + (math.pow((391.45) - (input[11]), 2))) + (math.pow((22.11) - (input[12]), 2))))) * (-0.017541052270521836))) + ((math.exp((var0) * (((((((((((((math.pow((0.61154) - (input[0]), 2)) + (math.pow((20.0) - (input[1]), 2))) + (math.pow((3.97) - (input[2]), 2))) + (math.pow((0.0) - (input[3]), 2))) + (math.pow((0.647) - (input[4]), 2))) + (math.pow((8.704) - (input[5]), 2))) + (math.pow((86.9) - (input[6]), 2))) + (math.pow((1.801) - (input[7]), 2))) + (math.pow((5.0) - (input[8]), 2))) + (math.pow((264.0) - (input[9]), 2))) + (math.pow((13.0) - (input[10]), 2))) + (math.pow((389.7) - (input[11]), 2))) + (math.pow((5.12) - (input[12]), 2))))) * (1.0))) + ((math.exp((var0) * (((((((((((((math.pow((10.8342) - (input[0]), 2)) + (math.pow((0.0) - (input[1]), 2))) + (math.pow((18.1) - (input[2]), 2))) + (math.pow((0.0) - (input[3]), 2))) + (math.pow((0.679) - (input[4]), 2))) + (math.pow((6.782) - (input[5]), 2))) + (math.pow((90.8) - (input[6]), 2))) + (math.pow((1.8195) - (input[7]), 2))) + (math.pow((24.0) - (input[8]), 2))) + (math.pow((666.0) - (input[9]), 2))) + (math.pow((20.2) - (input[10]), 2))) + (math.pow((21.57) - (input[11]), 2))) + (math.pow((25.79) - (input[12]), 2))))) * (-1.0))) + ((math.exp((var0) * (((((((((((((math.pow((15.8603) - (input[0]), 2)) + (math.pow((0.0) - (input[1]), 2))) + (math.pow((18.1) - (input[2]), 2))) + (math.pow((0.0) - (input[3]), 2))) + (math.pow((0.679) - (input[4]), 2))) + (math.pow((5.896) - (input[5]), 2))) + (math.pow((95.4) - (input[6]), 2))) + (math.pow((1.9096) - (input[7]), 2))) + (math.pow((24.0) - (input[8]), 2))) + (math.pow((666.0) - (input[9]), 2))) + (math.pow((20.2) - (input[10]), 2))) + (math.pow((7.68) - (input[11]), 2))) + (math.pow((24.39) - (input[12]), 2))))) * (-1.0))) + ((math.exp((var0) * (((((((((((((math.pow((17.8667) - (input[0]), 2)) + (math.pow((0.0) - (input[1]), 2))) + (math.pow((18.1) - (input[2]), 2))) + (math.pow((0.0) - (input[3]), 2))) + (math.pow((0.671) - (input[4]), 2))) + (math.pow((6.223) - (input[5]), 2))) + (math.pow((100.0) - (input[6]), 2))) + (math.pow((1.3861) - (input[7]), 2))) + (math.pow((24.0) - (input[8]), 2))) + (math.pow((666.0) - (input[9]), 2))) + (math.pow((20.2) - (input[10]), 2))) + (math.pow((393.74) - (input[11]), 2))) + (math.pow((21.78) - (input[12]), 2))))) * (-0.17127153707291753))) + ((math.exp((var0) * (((((((((((((math.pow((8.26725) - (input[0]), 2)) + (math.pow((0.0) - (input[1]), 2))) + (math.pow((18.1) - (input[2]), 2))) + (math.pow((1.0) - (input[3]), 2))) + (math.pow((0.668) - (input[4]), 2))) + (math.pow((5.875) - (input[5]), 2))) + (math.pow((89.6) - (input[6]), 2))) + (math.pow((1.1296) - (input[7]), 2))) + (math.pow((24.0) - (input[8]), 2))) + (math.pow((666.0) - (input[9]), 2))) + (math.pow((20.2) - (input[10]), 2))) + (math.pow((347.88) - (input[11]), 2))) + (math.pow((8.88) - (input[12]), 2))))) * (1.0))) + ((math.exp((var0) * (((((((((((((math.pow((0.52693) - (input[0]), 2)) + (math.pow((0.0) - (input[1]), 2))) + (math.pow((6.2) - (input[2]), 2))) + (math.pow((0.0) - (input[3]), 2))) + (math.pow((0.504) - (input[4]), 2))) + (math.pow((8.725) - (input[5]), 2))) + (math.pow((83.0) - (input[6]), 2))) + (math.pow((2.8944) - (input[7]), 2))) + (math.pow((8.0) - (input[8]), 2))) + (math.pow((307.0) - (input[9]), 2))) + (math.pow((17.4) - (input[10]), 2))) + (math.pow((382.0) - (input[11]), 2))) + (math.pow((4.63) - (input[12]), 2))))) * (1.0))) + ((math.exp((var0) * (((((((((((((math.pow((0.0351) - (input[0]), 2)) + (math.pow((95.0) - (input[1]), 2))) + (math.pow((2.68) - (input[2]), 2))) + (math.pow((0.0) - (input[3]), 2))) + (math.pow((0.4161) - (input[4]), 2))) + (math.pow((7.853) - (input[5]), 2))) + (math.pow((33.2) - (input[6]), 2))) + (math.pow((5.118) - (input[7]), 2))) + (math.pow((4.0) - (input[8]), 2))) + (math.pow((224.0) - (input[9]), 2))) + (math.pow((14.7) - (input[10]), 2))) + (math.pow((392.78) - (input[11]), 2))) + (math.pow((3.81) - (input[12]), 2))))) * (1.0))) + ((math.exp((var0) * (((((((((((((math.pow((12.2472) - (input[0]), 2)) + (math.pow((0.0) - (input[1]), 2))) + (math.pow((18.1) - (input[2]), 2))) + (math.pow((0.0) - (input[3]), 2))) + (math.pow((0.584) - (input[4]), 2))) + (math.pow((5.837) - (input[5]), 2))) + (math.pow((59.7) - (input[6]), 2))) + (math.pow((1.9976) - (input[7]), 2))) + (math.pow((24.0) - (input[8]), 2))) + (math.pow((666.0) - (input[9]), 2))) + (math.pow((20.2) - (input[10]), 2))) + (math.pow((24.65) - (input[11]), 2))) + (math.pow((15.69) - (input[12]), 2))))) * (-0.31798805038208666))) + ((math.exp((var0) * (((((((((((((math.pow((14.4208) - (input[0]), 2)) + (math.pow((0.0) - (input[1]), 2))) + (math.pow((18.1) - (input[2]), 2))) + (math.pow((0.0) - (input[3]), 2))) + (math.pow((0.74) - (input[4]), 2))) + (math.pow((6.461) - (input[5]), 2))) + (math.pow((93.3) - (input[6]), 2))) + (math.pow((2.0026) - (input[7]), 2))) + (math.pow((24.0) - (input[8]), 2))) + (math.pow((666.0) - (input[9]), 2))) + (math.pow((20.2) - (input[10]), 2))) + (math.pow((27.49) - (input[11]), 2))) + (math.pow((18.05) - (input[12]), 2))))) * (-0.9183413019645936))) + ((math.exp((var0) * (((((((((((((math.pow((0.29819) - (input[0]), 2)) + (math.pow((0.0) - (input[1]), 2))) + (math.pow((6.2) - (input[2]), 2))) + (math.pow((0.0) - (input[3]), 2))) + (math.pow((0.504) - (input[4]), 2))) + (math.pow((7.686) - (input[5]), 2))) + (math.pow((17.0) - (input[6]), 2))) + (math.pow((3.3751) - (input[7]), 2))) + (math.pow((8.0) - (input[8]), 2))) + (math.pow((307.0) - (input[9]), 2))) + (math.pow((17.4) - (input[10]), 2))) + (math.pow((377.51) - (input[11]), 2))) + (math.pow((3.92) - (input[12]), 2))))) * (1.0))) + ((math.exp((var0) * (((((((((((((math.pow((38.3518) - (input[0]), 2)) + (math.pow((0.0) - (input[1]), 2))) + (math.pow((18.1) - (input[2]), 2))) + (math.pow((0.0) - (input[3]), 2))) + (math.pow((0.693) - (input[4]), 2))) + (math.pow((5.453) - (input[5]), 2))) + (math.pow((100.0) - (input[6]), 2))) + (math.pow((1.4896) - (input[7]), 2))) + (math.pow((24.0) - (input[8]), 2))) + (math.pow((666.0) - (input[9]), 2))) + (math.pow((20.2) - (input[10]), 2))) + (math.pow((396.9) - (input[11]), 2))) + (math.pow((30.59) - (input[12]), 2))))) * (-1.0))) + ((math.exp((var0) * (((((((((((((math.pow((0.06129) - (input[0]), 2)) + (math.pow((20.0) - (input[1]), 2))) + (math.pow((3.33) - (input[2]), 2))) + (math.pow((1.0) - (input[3]), 2))) + (math.pow((0.4429) - (input[4]), 2))) + (math.pow((7.645) - (input[5]), 2))) + (math.pow((49.7) - (input[6]), 2))) + (math.pow((5.2119) - (input[7]), 2))) + (math.pow((5.0) - (input[8]), 2))) + (math.pow((216.0) - (input[9]), 2))) + (math.pow((14.9) - (input[10]), 2))) + (math.pow((377.07) - (input[11]), 2))) + (math.pow((3.01) - (input[12]), 2))))) * (1.0))) + ((math.exp((var0) * (((((((((((((math.pow((88.9762) - (input[0]), 2)) + (math.pow((0.0) - (input[1]), 2))) + (math.pow((18.1) - (input[2]), 2))) + (math.pow((0.0) - (input[3]), 2))) + (math.pow((0.671) - (input[4]), 2))) + (math.pow((6.968) - (input[5]), 2))) + (math.pow((91.9) - (input[6]), 2))) + (math.pow((1.4165) - (input[7]), 2))) + (math.pow((24.0) - (input[8]), 2))) + (math.pow((666.0) - (input[9]), 2))) + (math.pow((20.2) - (input[10]), 2))) + (math.pow((396.9) - (input[11]), 2))) + (math.pow((17.21) - (input[12]), 2))))) * (-0.11849528386764341))) + ((math.exp((var0) * (((((((((((((math.pow((0.05602) - (input[0]), 2)) + (math.pow((0.0) - (input[1]), 2))) + (math.pow((2.46) - (input[2]), 2))) + (math.pow((0.0) - (input[3]), 2))) + (math.pow((0.488) - (input[4]), 2))) + (math.pow((7.831) - (input[5]), 2))) + (math.pow((53.6) - (input[6]), 2))) + (math.pow((3.1992) - (input[7]), 2))) + (math.pow((3.0) - (input[8]), 2))) + (math.pow((193.0) - (input[9]), 2))) + (math.pow((17.8) - (input[10]), 2))) + (math.pow((392.63) - (input[11]), 2))) + (math.pow((4.45) - (input[12]), 2))))) * (1.0))) + ((math.exp((var0) * (((((((((((((math.pow((0.01501) - (input[0]), 2)) + (math.pow((90.0) - (input[1]), 2))) + (math.pow((1.21) - (input[2]), 2))) + (math.pow((1.0) - (input[3]), 2))) + (math.pow((0.401) - (input[4]), 2))) + (math.pow((7.923) - (input[5]), 2))) + (math.pow((24.8) - (input[6]), 2))) + (math.pow((5.885) - (input[7]), 2))) + (math.pow((1.0) - (input[8]), 2))) + (math.pow((198.0) - (input[9]), 2))) + (math.pow((13.6) - (input[10]), 2))) + (math.pow((395.52) - (input[11]), 2))) + (math.pow((3.16) - (input[12]), 2))))) * (1.0))) + ((math.exp((var0) * (((((((((((((math.pow((0.02009) - (input[0]), 2)) + (math.pow((95.0) - (input[1]), 2))) + (math.pow((2.68) - (input[2]), 2))) + (math.pow((0.0) - (input[3]), 2))) + (math.pow((0.4161) - (input[4]), 2))) + (math.pow((8.034) - (input[5]), 2))) + (math.pow((31.9) - (input[6]), 2))) + (math.pow((5.118) - (input[7]), 2))) + (math.pow((4.0) - (input[8]), 2))) + (math.pow((224.0) - (input[9]), 2))) + (math.pow((14.7) - (input[10]), 2))) + (math.pow((390.55) - (input[11]), 2))) + (math.pow((2.88) - (input[12]), 2))))) * (1.0))) + ((math.exp((var0) * (((((((((((((math.pow((15.1772) - (input[0]), 2)) + (math.pow((0.0) - (input[1]), 2))) + (math.pow((18.1) - (input[2]), 2))) + (math.pow((0.0) - (input[3]), 2))) + (math.pow((0.74) - (input[4]), 2))) + (math.pow((6.152) - (input[5]), 2))) + (math.pow((100.0) - (input[6]), 2))) + (math.pow((1.9142) - (input[7]), 2))) + (math.pow((24.0) - (input[8]), 2))) + (math.pow((666.0) - (input[9]), 2))) + (math.pow((20.2) - (input[10]), 2))) + (math.pow((9.32) - (input[11]), 2))) + (math.pow((26.45) - (input[12]), 2))))) * (-1.0))) + ((math.exp((var0) * (((((((((((((math.pow((18.0846) - (input[0]), 2)) + (math.pow((0.0) - (input[1]), 2))) + (math.pow((18.1) - (input[2]), 2))) + (math.pow((0.0) - (input[3]), 2))) + (math.pow((0.679) - (input[4]), 2))) + (math.pow((6.434) - (input[5]), 2))) + (math.pow((100.0) - (input[6]), 2))) + (math.pow((1.8347) - (input[7]), 2))) + (math.pow((24.0) - (input[8]), 2))) + (math.pow((666.0) - (input[9]), 2))) + (math.pow((20.2) - (input[10]), 2))) + (math.pow((27.25) - (input[11]), 2))) + (math.pow((29.05) - (input[12]), 2))))) * (-1.0))) + ((math.exp((var0) * (((((((((((((math.pow((0.01381) - (input[0]), 2)) + (math.pow((80.0) - (input[1]), 2))) + (math.pow((0.46) - (input[2]), 2))) + (math.pow((0.0) - (input[3]), 2))) + (math.pow((0.422) - (input[4]), 2))) + (math.pow((7.875) - (input[5]), 2))) + (math.pow((32.0) - (input[6]), 2))) + (math.pow((5.6484) - (input[7]), 2))) + (math.pow((4.0) - (input[8]), 2))) + (math.pow((255.0) - (input[9]), 2))) + (math.pow((14.4) - (input[10]), 2))) + (math.pow((394.23) - (input[11]), 2))) + (math.pow((2.97) - (input[12]), 2))))) * (1.0))) + ((math.exp((var0) * (((((((((((((math.pow((5.66998) - (input[0]), 2)) + (math.pow((0.0) - (input[1]), 2))) + (math.pow((18.1) - (input[2]), 2))) + (math.pow((1.0) - (input[3]), 2))) + (math.pow((0.631) - (input[4]), 2))) + (math.pow((6.683) - (input[5]), 2))) + (math.pow((96.8) - (input[6]), 2))) + (math.pow((1.3567) - (input[7]), 2))) + (math.pow((24.0) - (input[8]), 2))) + (math.pow((666.0) - (input[9]), 2))) + (math.pow((20.2) - (input[10]), 2))) + (math.pow((375.33) - (input[11]), 2))) + (math.pow((3.73) - (input[12]), 2))))) * (1.0))) + ((math.exp((var0) * (((((((((((((math.pow((0.01538) - (input[0]), 2)) + (math.pow((90.0) - (input[1]), 2))) + (math.pow((3.75) - (input[2]), 2))) + (math.pow((0.0) - (input[3]), 2))) + (math.pow((0.394) - (input[4]), 2))) + (math.pow((7.454) - (input[5]), 2))) + (math.pow((34.2) - (input[6]), 2))) + (math.pow((6.3361) - (input[7]), 2))) + (math.pow((3.0) - (input[8]), 2))) + (math.pow((244.0) - (input[9]), 2))) + (math.pow((15.9) - (input[10]), 2))) + (math.pow((386.34) - (input[11]), 2))) + (math.pow((3.11) - (input[12]), 2))))) * (0.47499999996189857))) + ((math.exp((var0) * (((((((((((((math.pow((4.89822) - (input[0]), 2)) + (math.pow((0.0) - (input[1]), 2))) + (math.pow((18.1) - (input[2]), 2))) + (math.pow((0.0) - (input[3]), 2))) + (math.pow((0.631) - (input[4]), 2))) + (math.pow((4.97) - (input[5]), 2))) + (math.pow((100.0) - (input[6]), 2))) + (math.pow((1.3325) - (input[7]), 2))) + (math.pow((24.0) - (input[8]), 2))) + (math.pow((666.0) - (input[9]), 2))) + (math.pow((20.2) - (input[10]), 2))) + (math.pow((375.52) - (input[11]), 2))) + (math.pow((3.26) - (input[12]), 2))))) * (1.0))) + ((math.exp((var0) * (((((((((((((math.pow((2.01019) - (input[0]), 2)) + (math.pow((0.0) - (input[1]), 2))) + (math.pow((19.58) - (input[2]), 2))) + (math.pow((0.0) - (input[3]), 2))) + (math.pow((0.605) - (input[4]), 2))) + (math.pow((7.929) - (input[5]), 2))) + (math.pow((96.2) - (input[6]), 2))) + (math.pow((2.0459) - (input[7]), 2))) + (math.pow((5.0) - (input[8]), 2))) + (math.pow((403.0) - (input[9]), 2))) + (math.pow((14.7) - (input[10]), 2))) + (math.pow((369.3) - (input[11]), 2))) + (math.pow((3.7) - (input[12]), 2))))) * (1.0))) + ((math.exp((var0) * (((((((((((((math.pow((0.52014) - (input[0]), 2)) + (math.pow((20.0) - (input[1]), 2))) + (math.pow((3.97) - (input[2]), 2))) + (math.pow((0.0) - (input[3]), 2))) + (math.pow((0.647) - (input[4]), 2))) + (math.pow((8.398) - (input[5]), 2))) + (math.pow((91.5) - (input[6]), 2))) + (math.pow((2.2885) - (input[7]), 2))) + (math.pow((5.0) - (input[8]), 2))) + (math.pow((264.0) - (input[9]), 2))) + (math.pow((13.0) - (input[10]), 2))) + (math.pow((386.86) - (input[11]), 2))) + (math.pow((5.91) - (input[12]), 2))))) * (1.0))) + ((math.exp((var0) * (((((((((((((math.pow((9.33889) - (input[0]), 2)) + (math.pow((0.0) - (input[1]), 2))) + (math.pow((18.1) - (input[2]), 2))) + (math.pow((0.0) - (input[3]), 2))) + (math.pow((0.679) - (input[4]), 2))) + (math.pow((6.38) - (input[5]), 2))) + (math.pow((95.6) - (input[6]), 2))) + (math.pow((1.9682) - (input[7]), 2))) + (math.pow((24.0) - (input[8]), 2))) + (math.pow((666.0) - (input[9]), 2))) + (math.pow((20.2) - (input[10]), 2))) + (math.pow((60.72) - (input[11]), 2))) + (math.pow((24.08) - (input[12]), 2))))) * (-1.0))
diff --git a/m2cgen/ast.py b/m2cgen/ast.py
index a748a488..a914cd75 100644
--- a/m2cgen/ast.py
+++ b/m2cgen/ast.py
@@ -39,6 +39,8 @@ def __str__(self):
 
 class ExpExpr(NumExpr):
     def __init__(self, expr, to_reuse=False):
+        assert expr.output_size == 1, "Only scalars are supported"
+
         self.expr = expr
         self.to_reuse = to_reuse
 
@@ -49,6 +51,8 @@ def __str__(self):
 
 class TanhExpr(NumExpr):
     def __init__(self, expr, to_reuse=False):
+        assert expr.output_size == 1, "Only scalars are supported"
+
         self.expr = expr
         self.to_reuse = to_reuse
 
@@ -59,6 +63,9 @@ def __str__(self):
 
 class PowExpr(NumExpr, BinExpr):
     def __init__(self, base_expr, exp_expr, to_reuse=False):
+        assert base_expr.output_size == 1, "Only scalars are supported"
+        assert exp_expr.output_size == 1, "Only scalars are supported"
+
         self.base_expr = base_expr
         self.exp_expr = exp_expr
         self.to_reuse = to_reuse
diff --git a/m2cgen/interpreters/python/code_generator.py b/m2cgen/interpreters/python/code_generator.py
index 3d25bbbd..2527905a 100644
--- a/m2cgen/interpreters/python/code_generator.py
+++ b/m2cgen/interpreters/python/code_generator.py
@@ -10,6 +10,7 @@ class PythonCodeGenerator(BaseCodeGenerator):
     tpl_infix_expression = CT("(${left}) ${op} (${right})")
     tpl_return_statement = CT("return ${value}")
     tpl_array_index_access = CT("${array_name}[${index}]")
+    tpl_array_convert_to_numpy = CT("np.asarray(${value})")
     tpl_if_statement = CT("if ${if_def}:")
     tpl_else_statement = CT("else:")
     tpl_var_assignment = CT("${var_name} = ${value}")
@@ -30,7 +31,10 @@ def function_definition(self, name, args):
         yield
 
     def vector_init(self, values):
-        return "np.asarray([" + ", ".join(values) + "])"
+        return "[" + ", ".join(values) + "]"
+
+    def array_convert_to_numpy(self, value):
+        return self.tpl_array_convert_to_numpy(value=value)
 
     def add_dependency(self, dep, alias=None):
         dep_str = "import " + dep
diff --git a/m2cgen/interpreters/python/interpreter.py b/m2cgen/interpreters/python/interpreter.py
index 600766b9..f90dabde 100644
--- a/m2cgen/interpreters/python/interpreter.py
+++ b/m2cgen/interpreters/python/interpreter.py
@@ -4,14 +4,15 @@
 
 
 class PythonInterpreter(ToCodeInterpreter,
-                        mixins.BinExpressionDepthTrackingMixin):
+                        mixins.BinExpressionDepthTrackingMixin,
+                        mixins.LinearAlgebraMixin):
 
     # 60 raises MemoryError for some SVM models with RBF kernel.
     bin_depth_threshold = 55
 
-    exponent_function_name = "np.exp"
-    power_function_name = "np.power"
-    tanh_function_name = "np.tanh"
+    exponent_function_name = "math.exp"
+    power_function_name = "math.pow"
+    tanh_function_name = "math.tanh"
 
     def __init__(self, indent=4, *args, **kwargs):
         cg = PythonCodeGenerator(indent=indent)
@@ -27,19 +28,27 @@ def interpret(self, expr):
             last_result = self._do_interpret(expr)
             self._cg.add_return_statement(last_result)
 
-        if self.with_vectors or self.with_math_module:
+        if self.with_math_module:
+            self._cg.add_dependency("math")
+
+        if self.with_linear_algebra:
             self._cg.add_dependency("numpy", alias="np")
 
         return self._cg.code
 
     def interpret_bin_vector_expr(self, expr, **kwargs):
+        self.with_linear_algebra = True
         return self._cg.infix_expression(
-            left=self._do_interpret(expr.left, **kwargs),
+            left=self._cg.array_convert_to_numpy(
+                self._do_interpret(expr.left, **kwargs)),
             op=expr.op.value,
-            right=self._do_interpret(expr.right, **kwargs))
+            right=self._cg.array_convert_to_numpy(
+                self._do_interpret(expr.right, **kwargs)))
 
     def interpret_bin_vector_num_expr(self, expr, **kwargs):
+        self.with_linear_algebra = True
         return self._cg.infix_expression(
-            left=self._do_interpret(expr.left, **kwargs),
+            left=self._cg.array_convert_to_numpy(
+                self._do_interpret(expr.left, **kwargs)),
             op=expr.op.value,
             right=self._do_interpret(expr.right, **kwargs))


Test patch:
diff --git a/tests/interpreters/test_python.py b/tests/interpreters/test_python.py
index 07efc729..71cf7bb7 100644
--- a/tests/interpreters/test_python.py
+++ b/tests/interpreters/test_python.py
@@ -18,7 +18,7 @@ def score(input):
     else:
         var0 = 3
     return var0
-"""
+    """
 
     utils.assert_code_equal(interpreter.interpret(expr), expected_code)
 
@@ -126,14 +126,13 @@ def test_multi_output():
             ast.VectorVal([ast.NumVal(3), ast.NumVal(4)])))
 
     expected_code = """
-import numpy as np
 def score(input):
     if (1) == (1):
-        var0 = np.asarray([1, 2])
+        var0 = [1, 2]
     else:
-        var0 = np.asarray([3, 4])
+        var0 = [3, 4]
     return var0
-"""
+    """
 
     interpreter = interpreters.PythonInterpreter()
     utils.assert_code_equal(interpreter.interpret(expr), expected_code)
@@ -151,7 +150,8 @@ def test_bin_vector_expr():
 import numpy as np
 def score(input):
     return (np.asarray([1, 2])) * (np.asarray([3, 4]))
-"""
+    """
+
     utils.assert_code_equal(interpreter.interpret(expr), expected_code)
 
 
@@ -167,7 +167,8 @@ def test_bin_vector_num_expr():
 import numpy as np
 def score(input):
     return (np.asarray([1, 2])) * (1)
-"""
+    """
+
     utils.assert_code_equal(interpreter.interpret(expr), expected_code)
 
 
@@ -185,7 +186,9 @@ def test_depth_threshold_with_bin_expr():
     expected_code = """
 def score(input):
     var0 = (1) + ((1) + (1))
-    return (1) + ((1) + (var0))"""
+    return (1) + ((1) + (var0))
+    """
+
     utils.assert_code_equal(interpreter.interpret(expr), expected_code)
 
 
@@ -215,7 +218,9 @@ def score(input):
                     var0 = 1
                 else:
                     var0 = 1
-    return var0"""
+    return var0
+    """
+
     utils.assert_code_equal(interpreter.interpret(expr), expected_code)
 
 
@@ -249,7 +254,9 @@ def score(input):
                     var0 = 1
                 else:
                     var0 = 1
-    return var0"""
+    return var0
+    """
+
     utils.assert_code_equal(interpreter.interpret(expr), expected_code)
 
 
@@ -287,7 +294,9 @@ def score(input):
                     var0 = 1
                 else:
                     var0 = 1
-    return var0"""
+    return var0
+    """
+
     utils.assert_code_equal(interpreter.interpret(expr), expected_code)
 
 
@@ -315,9 +324,10 @@ def test_exp_expr():
     interpreter = interpreters.PythonInterpreter()
 
     expected_code = """
-import numpy as np
+import math
 def score(input):
-    return np.exp(1.0)"""
+    return math.exp(1.0)
+    """
 
     utils.assert_code_equal(interpreter.interpret(expr), expected_code)
 
@@ -328,9 +338,10 @@ def test_pow_expr():
     interpreter = interpreters.PythonInterpreter()
 
     expected_code = """
-import numpy as np
+import math
 def score(input):
-    return np.power(2.0, 3.0)"""
+    return math.pow(2.0, 3.0)
+    """
 
     utils.assert_code_equal(interpreter.interpret(expr), expected_code)
 
@@ -341,9 +352,10 @@ def test_tanh_expr():
     interpreter = interpreters.PythonInterpreter()
 
     expected_code = """
-import numpy as np
+import math
 def score(input):
-    return np.tanh(2.0)"""
+    return math.tanh(2.0)
+    """
 
     utils.assert_code_equal(interpreter.interpret(expr), expected_code)
 
@@ -355,9 +367,10 @@ def test_reused_expr():
     interpreter = interpreters.PythonInterpreter()
 
     expected_code = """
-import numpy as np
+import math
 def score(input):
-    var0 = np.exp(1.0)
-    return (var0) / (var0)"""
+    var0 = math.exp(1.0)
+    return (var0) / (var0)
+    """
 
     utils.assert_code_equal(interpreter.interpret(expr), expected_code)